YES 18.462 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/FiniteMap.hs
H-Termination of the given Haskell-Program with start terms could successfully be proven:



↳ HASKELL
  ↳ LR

mainModule FiniteMap
  ((filterFM :: Ord b => (b  ->  a  ->  Bool)  ->  FiniteMap b a  ->  FiniteMap b a) :: Ord b => (b  ->  a  ->  Bool)  ->  FiniteMap b a  ->  FiniteMap b a)

module FiniteMap where
  import qualified Maybe
import qualified Prelude
  data FiniteMap b a = EmptyFM  | Branch b a Int (FiniteMap b a) (FiniteMap b a) 
  instance (Eq a, Eq b) => Eq (FiniteMap b a) where 
   
(==) fm_1 fm_2 = sizeFM fm_1 == sizeFM fm_2 && fmToList fm_1 == fmToList fm_2

  addToFM :: Ord a => FiniteMap a b  ->  a  ->  b  ->  FiniteMap a b
addToFM fm key elt = addToFM_C (\old new ->new) fm key elt

  addToFM_C :: Ord a => (b  ->  b  ->  b)  ->  FiniteMap a b  ->  a  ->  b  ->  FiniteMap a b
addToFM_C combiner EmptyFM key elt = unitFM key elt
addToFM_C combiner (Branch key elt size fm_l fm_r) new_key new_elt 
 | new_key < key = 
mkBalBranch key elt (addToFM_C combiner fm_l new_key new_elt) fm_r
 | new_key > key = 
mkBalBranch key elt fm_l (addToFM_C combiner fm_r new_key new_elt)
 | otherwise = 
Branch new_key (combiner elt new_elt) size fm_l fm_r

  deleteMax :: Ord a => FiniteMap a b  ->  FiniteMap a b
deleteMax (Branch key elt _ fm_l EmptyFM) = fm_l
deleteMax (Branch key elt _ fm_l fm_r) = mkBalBranch key elt fm_l (deleteMax fm_r)

  deleteMin :: Ord b => FiniteMap b a  ->  FiniteMap b a
deleteMin (Branch key elt _ EmptyFM fm_r) = fm_r
deleteMin (Branch key elt _ fm_l fm_r) = mkBalBranch key elt (deleteMin fm_l) fm_r

  emptyFM :: FiniteMap b a
emptyFM = EmptyFM

  filterFM :: Ord a => (a  ->  b  ->  Bool)  ->  FiniteMap a b  ->  FiniteMap a b
filterFM p EmptyFM = emptyFM
filterFM p (Branch key elt _ fm_l fm_r) 
 | p key elt = 
mkVBalBranch key elt (filterFM p fm_l) (filterFM p fm_r)
 | otherwise = 
glueVBal (filterFM p fm_l) (filterFM p fm_r)

  findMax :: FiniteMap a b  ->  (a,b)
findMax (Branch key elt _ _ EmptyFM) = (key,elt)
findMax (Branch key elt _ _ fm_r) = findMax fm_r

  findMin :: FiniteMap b a  ->  (b,a)
findMin (Branch key elt _ EmptyFM _) = (key,elt)
findMin (Branch key elt _ fm_l _) = findMin fm_l

  fmToList :: FiniteMap a b  ->  [(a,b)]
fmToList fm = foldFM (\key elt rest ->(key,elt) : rest) [] fm

  foldFM :: (a  ->  c  ->  b  ->  b)  ->  b  ->  FiniteMap a c  ->  b
foldFM k z EmptyFM = z
foldFM k z (Branch key elt _ fm_l fm_r) = foldFM k (k key elt (foldFM k z fm_r)) fm_l

  glueBal :: Ord a => FiniteMap a b  ->  FiniteMap a b  ->  FiniteMap a b
glueBal EmptyFM fm2 = fm2
glueBal fm1 EmptyFM = fm1
glueBal fm1 fm2 
 | sizeFM fm2 > sizeFM fm1 = 
mkBalBranch mid_key2 mid_elt2 fm1 (deleteMin fm2)
 | otherwise = 
mkBalBranch mid_key1 mid_elt1 (deleteMax fm1) fm2 where 
mid_elt1 = (\(_,mid_elt1) ->mid_elt1) vv2
mid_elt2 = (\(_,mid_elt2) ->mid_elt2) vv3
mid_key1 = (\(mid_key1,_) ->mid_key1) vv2
mid_key2 = (\(mid_key2,_) ->mid_key2) vv3
vv2 = findMax fm1
vv3 = findMin fm2

  glueVBal :: Ord b => FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
glueVBal EmptyFM fm2 = fm2
glueVBal fm1 EmptyFM = fm1
glueVBal fm_l@(Branch key_l elt_l _ fm_ll fm_lr) fm_r@(Branch key_r elt_r _ fm_rl fm_rr) 
 | sIZE_RATIO * size_l < size_r = 
mkBalBranch key_r elt_r (glueVBal fm_l fm_rl) fm_rr
 | sIZE_RATIO * size_r < size_l = 
mkBalBranch key_l elt_l fm_ll (glueVBal fm_lr fm_r)
 | otherwise = 
glueBal fm_l fm_r where 
size_l = sizeFM fm_l
size_r = sizeFM fm_r

  mkBalBranch :: Ord b => b  ->  a  ->  FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
mkBalBranch key elt fm_L fm_R 
 | size_l + size_r < 2 = 
mkBranch 1 key elt fm_L fm_R
 | size_r > sIZE_RATIO * size_l = 
case fm_R of
  Branch _ _ _ fm_rl fm_rr
 | sizeFM fm_rl < 2 * sizeFM fm_rr -> 
single_L fm_L fm_R
 | otherwise -> 
double_L fm_L fm_R
 | size_l > sIZE_RATIO * size_r = 
case fm_L of
  Branch _ _ _ fm_ll fm_lr
 | sizeFM fm_lr < 2 * sizeFM fm_ll -> 
single_R fm_L fm_R
 | otherwise -> 
double_R fm_L fm_R
 | otherwise = 
mkBranch 2 key elt fm_L fm_R where 
double_L fm_l (Branch key_r elt_r _ (Branch key_rl elt_rl _ fm_rll fm_rlr) fm_rr) = mkBranch 5 key_rl elt_rl (mkBranch 6 key elt fm_l fm_rll) (mkBranch 7 key_r elt_r fm_rlr fm_rr)
double_R (Branch key_l elt_l _ fm_ll (Branch key_lr elt_lr _ fm_lrl fm_lrr)) fm_r = mkBranch 10 key_lr elt_lr (mkBranch 11 key_l elt_l fm_ll fm_lrl) (mkBranch 12 key elt fm_lrr fm_r)
single_L fm_l (Branch key_r elt_r _ fm_rl fm_rr) = mkBranch 3 key_r elt_r (mkBranch 4 key elt fm_l fm_rl) fm_rr
single_R (Branch key_l elt_l _ fm_ll fm_lr) fm_r = mkBranch 8 key_l elt_l fm_ll (mkBranch 9 key elt fm_lr fm_r)
size_l = sizeFM fm_L
size_r = sizeFM fm_R

  mkBranch :: Ord b => Int  ->  b  ->  a  ->  FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
mkBranch which key elt fm_l fm_r = 
let 
result = Branch key elt (unbox (1 + left_size + right_size)) fm_l fm_r
in result
 where 
balance_ok = True
left_ok = 
case fm_l of
  EmptyFM-> True
  Branch left_key _ _ _ _-> 
let 
biggest_left_key = fst (findMax fm_l)
in biggest_left_key < key
left_size = sizeFM fm_l
right_ok = 
case fm_r of
  EmptyFM-> True
  Branch right_key _ _ _ _-> 
let 
smallest_right_key = fst (findMin fm_r)
in key < smallest_right_key
right_size = sizeFM fm_r
unbox :: Int  ->  Int
unbox x = x

  mkVBalBranch :: Ord b => b  ->  a  ->  FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
mkVBalBranch key elt EmptyFM fm_r = addToFM fm_r key elt
mkVBalBranch key elt fm_l EmptyFM = addToFM fm_l key elt
mkVBalBranch key elt fm_l@(Branch key_l elt_l _ fm_ll fm_lr) fm_r@(Branch key_r elt_r _ fm_rl fm_rr) 
 | sIZE_RATIO * size_l < size_r = 
mkBalBranch key_r elt_r (mkVBalBranch key elt fm_l fm_rl) fm_rr
 | sIZE_RATIO * size_r < size_l = 
mkBalBranch key_l elt_l fm_ll (mkVBalBranch key elt fm_lr fm_r)
 | otherwise = 
mkBranch 13 key elt fm_l fm_r where 
size_l = sizeFM fm_l
size_r = sizeFM fm_r

  sIZE_RATIO :: Int
sIZE_RATIO = 5

  sizeFM :: FiniteMap a b  ->  Int
sizeFM EmptyFM = 0
sizeFM (Branch _ _ size _ _) = size

  unitFM :: b  ->  a  ->  FiniteMap b a
unitFM key elt = Branch key elt 1 emptyFM emptyFM


module Maybe where
  import qualified FiniteMap
import qualified Prelude


Lambda Reductions:
The following Lambda expression
\(mid_key1,_)→mid_key1

is transformed to
mid_key10 (mid_key1,_) = mid_key1

The following Lambda expression
\(_,mid_elt1)→mid_elt1

is transformed to
mid_elt10 (_,mid_elt1) = mid_elt1

The following Lambda expression
\(mid_key2,_)→mid_key2

is transformed to
mid_key20 (mid_key2,_) = mid_key2

The following Lambda expression
\(_,mid_elt2)→mid_elt2

is transformed to
mid_elt20 (_,mid_elt2) = mid_elt2

The following Lambda expression
\keyeltrest→(key,elt) : rest

is transformed to
fmToList0 key elt rest = (key,elt) : rest

The following Lambda expression
\oldnew→new

is transformed to
addToFM0 old new = new



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR

mainModule FiniteMap
  ((filterFM :: Ord a => (a  ->  b  ->  Bool)  ->  FiniteMap a b  ->  FiniteMap a b) :: Ord a => (a  ->  b  ->  Bool)  ->  FiniteMap a b  ->  FiniteMap a b)

module FiniteMap where
  import qualified Maybe
import qualified Prelude
  data FiniteMap b a = EmptyFM  | Branch b a Int (FiniteMap b a) (FiniteMap b a) 
  instance (Eq a, Eq b) => Eq (FiniteMap b a) where 
   
(==) fm_1 fm_2 = sizeFM fm_1 == sizeFM fm_2 && fmToList fm_1 == fmToList fm_2

  addToFM :: Ord a => FiniteMap a b  ->  a  ->  b  ->  FiniteMap a b
addToFM fm key elt = addToFM_C addToFM0 fm key elt

  
addToFM0 old new = new

  addToFM_C :: Ord b => (a  ->  a  ->  a)  ->  FiniteMap b a  ->  b  ->  a  ->  FiniteMap b a
addToFM_C combiner EmptyFM key elt = unitFM key elt
addToFM_C combiner (Branch key elt size fm_l fm_r) new_key new_elt 
 | new_key < key = 
mkBalBranch key elt (addToFM_C combiner fm_l new_key new_elt) fm_r
 | new_key > key = 
mkBalBranch key elt fm_l (addToFM_C combiner fm_r new_key new_elt)
 | otherwise = 
Branch new_key (combiner elt new_elt) size fm_l fm_r

  deleteMax :: Ord a => FiniteMap a b  ->  FiniteMap a b
deleteMax (Branch key elt _ fm_l EmptyFM) = fm_l
deleteMax (Branch key elt _ fm_l fm_r) = mkBalBranch key elt fm_l (deleteMax fm_r)

  deleteMin :: Ord a => FiniteMap a b  ->  FiniteMap a b
deleteMin (Branch key elt _ EmptyFM fm_r) = fm_r
deleteMin (Branch key elt _ fm_l fm_r) = mkBalBranch key elt (deleteMin fm_l) fm_r

  emptyFM :: FiniteMap a b
emptyFM = EmptyFM

  filterFM :: Ord b => (b  ->  a  ->  Bool)  ->  FiniteMap b a  ->  FiniteMap b a
filterFM p EmptyFM = emptyFM
filterFM p (Branch key elt _ fm_l fm_r) 
 | p key elt = 
mkVBalBranch key elt (filterFM p fm_l) (filterFM p fm_r)
 | otherwise = 
glueVBal (filterFM p fm_l) (filterFM p fm_r)

  findMax :: FiniteMap b a  ->  (b,a)
findMax (Branch key elt _ _ EmptyFM) = (key,elt)
findMax (Branch key elt _ _ fm_r) = findMax fm_r

  findMin :: FiniteMap a b  ->  (a,b)
findMin (Branch key elt _ EmptyFM _) = (key,elt)
findMin (Branch key elt _ fm_l _) = findMin fm_l

  fmToList :: FiniteMap a b  ->  [(a,b)]
fmToList fm = foldFM fmToList0 [] fm

  
fmToList0 key elt rest = (key,elt) : rest

  foldFM :: (b  ->  c  ->  a  ->  a)  ->  a  ->  FiniteMap b c  ->  a
foldFM k z EmptyFM = z
foldFM k z (Branch key elt _ fm_l fm_r) = foldFM k (k key elt (foldFM k z fm_r)) fm_l

  glueBal :: Ord b => FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
glueBal EmptyFM fm2 = fm2
glueBal fm1 EmptyFM = fm1
glueBal fm1 fm2 
 | sizeFM fm2 > sizeFM fm1 = 
mkBalBranch mid_key2 mid_elt2 fm1 (deleteMin fm2)
 | otherwise = 
mkBalBranch mid_key1 mid_elt1 (deleteMax fm1) fm2 where 
mid_elt1 = mid_elt10 vv2
mid_elt10 (_,mid_elt1) = mid_elt1
mid_elt2 = mid_elt20 vv3
mid_elt20 (_,mid_elt2) = mid_elt2
mid_key1 = mid_key10 vv2
mid_key10 (mid_key1,_) = mid_key1
mid_key2 = mid_key20 vv3
mid_key20 (mid_key2,_) = mid_key2
vv2 = findMax fm1
vv3 = findMin fm2

  glueVBal :: Ord a => FiniteMap a b  ->  FiniteMap a b  ->  FiniteMap a b
glueVBal EmptyFM fm2 = fm2
glueVBal fm1 EmptyFM = fm1
glueVBal fm_l@(Branch key_l elt_l _ fm_ll fm_lr) fm_r@(Branch key_r elt_r _ fm_rl fm_rr) 
 | sIZE_RATIO * size_l < size_r = 
mkBalBranch key_r elt_r (glueVBal fm_l fm_rl) fm_rr
 | sIZE_RATIO * size_r < size_l = 
mkBalBranch key_l elt_l fm_ll (glueVBal fm_lr fm_r)
 | otherwise = 
glueBal fm_l fm_r where 
size_l = sizeFM fm_l
size_r = sizeFM fm_r

  mkBalBranch :: Ord b => b  ->  a  ->  FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
mkBalBranch key elt fm_L fm_R 
 | size_l + size_r < 2 = 
mkBranch 1 key elt fm_L fm_R
 | size_r > sIZE_RATIO * size_l = 
case fm_R of
  Branch _ _ _ fm_rl fm_rr
 | sizeFM fm_rl < 2 * sizeFM fm_rr -> 
single_L fm_L fm_R
 | otherwise -> 
double_L fm_L fm_R
 | size_l > sIZE_RATIO * size_r = 
case fm_L of
  Branch _ _ _ fm_ll fm_lr
 | sizeFM fm_lr < 2 * sizeFM fm_ll -> 
single_R fm_L fm_R
 | otherwise -> 
double_R fm_L fm_R
 | otherwise = 
mkBranch 2 key elt fm_L fm_R where 
double_L fm_l (Branch key_r elt_r _ (Branch key_rl elt_rl _ fm_rll fm_rlr) fm_rr) = mkBranch 5 key_rl elt_rl (mkBranch 6 key elt fm_l fm_rll) (mkBranch 7 key_r elt_r fm_rlr fm_rr)
double_R (Branch key_l elt_l _ fm_ll (Branch key_lr elt_lr _ fm_lrl fm_lrr)) fm_r = mkBranch 10 key_lr elt_lr (mkBranch 11 key_l elt_l fm_ll fm_lrl) (mkBranch 12 key elt fm_lrr fm_r)
single_L fm_l (Branch key_r elt_r _ fm_rl fm_rr) = mkBranch 3 key_r elt_r (mkBranch 4 key elt fm_l fm_rl) fm_rr
single_R (Branch key_l elt_l _ fm_ll fm_lr) fm_r = mkBranch 8 key_l elt_l fm_ll (mkBranch 9 key elt fm_lr fm_r)
size_l = sizeFM fm_L
size_r = sizeFM fm_R

  mkBranch :: Ord b => Int  ->  b  ->  a  ->  FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
mkBranch which key elt fm_l fm_r = 
let 
result = Branch key elt (unbox (1 + left_size + right_size)) fm_l fm_r
in result
 where 
balance_ok = True
left_ok = 
case fm_l of
  EmptyFM-> True
  Branch left_key _ _ _ _-> 
let 
biggest_left_key = fst (findMax fm_l)
in biggest_left_key < key
left_size = sizeFM fm_l
right_ok = 
case fm_r of
  EmptyFM-> True
  Branch right_key _ _ _ _-> 
let 
smallest_right_key = fst (findMin fm_r)
in key < smallest_right_key
right_size = sizeFM fm_r
unbox :: Int  ->  Int
unbox x = x

  mkVBalBranch :: Ord a => a  ->  b  ->  FiniteMap a b  ->  FiniteMap a b  ->  FiniteMap a b
mkVBalBranch key elt EmptyFM fm_r = addToFM fm_r key elt
mkVBalBranch key elt fm_l EmptyFM = addToFM fm_l key elt
mkVBalBranch key elt fm_l@(Branch key_l elt_l _ fm_ll fm_lr) fm_r@(Branch key_r elt_r _ fm_rl fm_rr) 
 | sIZE_RATIO * size_l < size_r = 
mkBalBranch key_r elt_r (mkVBalBranch key elt fm_l fm_rl) fm_rr
 | sIZE_RATIO * size_r < size_l = 
mkBalBranch key_l elt_l fm_ll (mkVBalBranch key elt fm_lr fm_r)
 | otherwise = 
mkBranch 13 key elt fm_l fm_r where 
size_l = sizeFM fm_l
size_r = sizeFM fm_r

  sIZE_RATIO :: Int
sIZE_RATIO = 5

  sizeFM :: FiniteMap b a  ->  Int
sizeFM EmptyFM = 0
sizeFM (Branch _ _ size _ _) = size

  unitFM :: b  ->  a  ->  FiniteMap b a
unitFM key elt = Branch key elt 1 emptyFM emptyFM


module Maybe where
  import qualified FiniteMap
import qualified Prelude


Case Reductions:
The following Case expression
case fm_l of
 EmptyFM → True
 Branch left_key _ _ _ _ → 
let 
biggest_left_key  = fst (findMax fm_l)
in biggest_left_key < key

is transformed to
left_ok0 fm_l key EmptyFM = True
left_ok0 fm_l key (Branch left_key _ _ _ _) = 
let 
biggest_left_key  = fst (findMax fm_l)
in biggest_left_key < key

The following Case expression
case fm_r of
 EmptyFM → True
 Branch right_key _ _ _ _ → 
let 
smallest_right_key  = fst (findMin fm_r)
in key < smallest_right_key

is transformed to
right_ok0 fm_r key EmptyFM = True
right_ok0 fm_r key (Branch right_key _ _ _ _) = 
let 
smallest_right_key  = fst (findMin fm_r)
in key < smallest_right_key

The following Case expression
case fm_R of
 Branch _ _ _ fm_rl fm_rr
 | sizeFM fm_rl < 2 * sizeFM fm_rr
 → single_L fm_L fm_R
 | otherwise
 → double_L fm_L fm_R

is transformed to
mkBalBranch0 fm_L fm_R (Branch _ _ _ fm_rl fm_rr)
 | sizeFM fm_rl < 2 * sizeFM fm_rr
 = single_L fm_L fm_R
 | otherwise
 = double_L fm_L fm_R

The following Case expression
case fm_L of
 Branch _ _ _ fm_ll fm_lr
 | sizeFM fm_lr < 2 * sizeFM fm_ll
 → single_R fm_L fm_R
 | otherwise
 → double_R fm_L fm_R

is transformed to
mkBalBranch1 fm_L fm_R (Branch _ _ _ fm_ll fm_lr)
 | sizeFM fm_lr < 2 * sizeFM fm_ll
 = single_R fm_L fm_R
 | otherwise
 = double_R fm_L fm_R

The following Case expression
case compare x y of
 EQ → o
 LT → LT
 GT → GT

is transformed to
primCompAux0 o EQ = o
primCompAux0 o LT = LT
primCompAux0 o GT = GT



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR

mainModule FiniteMap
  ((filterFM :: Ord b => (b  ->  a  ->  Bool)  ->  FiniteMap b a  ->  FiniteMap b a) :: Ord b => (b  ->  a  ->  Bool)  ->  FiniteMap b a  ->  FiniteMap b a)

module FiniteMap where
  import qualified Maybe
import qualified Prelude
  data FiniteMap b a = EmptyFM  | Branch b a Int (FiniteMap b a) (FiniteMap b a) 
  instance (Eq a, Eq b) => Eq (FiniteMap b a) where 
   
(==) fm_1 fm_2 = sizeFM fm_1 == sizeFM fm_2 && fmToList fm_1 == fmToList fm_2

  addToFM :: Ord b => FiniteMap b a  ->  b  ->  a  ->  FiniteMap b a
addToFM fm key elt = addToFM_C addToFM0 fm key elt

  
addToFM0 old new = new

  addToFM_C :: Ord b => (a  ->  a  ->  a)  ->  FiniteMap b a  ->  b  ->  a  ->  FiniteMap b a
addToFM_C combiner EmptyFM key elt = unitFM key elt
addToFM_C combiner (Branch key elt size fm_l fm_r) new_key new_elt 
 | new_key < key = 
mkBalBranch key elt (addToFM_C combiner fm_l new_key new_elt) fm_r
 | new_key > key = 
mkBalBranch key elt fm_l (addToFM_C combiner fm_r new_key new_elt)
 | otherwise = 
Branch new_key (combiner elt new_elt) size fm_l fm_r

  deleteMax :: Ord a => FiniteMap a b  ->  FiniteMap a b
deleteMax (Branch key elt _ fm_l EmptyFM) = fm_l
deleteMax (Branch key elt _ fm_l fm_r) = mkBalBranch key elt fm_l (deleteMax fm_r)

  deleteMin :: Ord a => FiniteMap a b  ->  FiniteMap a b
deleteMin (Branch key elt _ EmptyFM fm_r) = fm_r
deleteMin (Branch key elt _ fm_l fm_r) = mkBalBranch key elt (deleteMin fm_l) fm_r

  emptyFM :: FiniteMap a b
emptyFM = EmptyFM

  filterFM :: Ord b => (b  ->  a  ->  Bool)  ->  FiniteMap b a  ->  FiniteMap b a
filterFM p EmptyFM = emptyFM
filterFM p (Branch key elt _ fm_l fm_r) 
 | p key elt = 
mkVBalBranch key elt (filterFM p fm_l) (filterFM p fm_r)
 | otherwise = 
glueVBal (filterFM p fm_l) (filterFM p fm_r)

  findMax :: FiniteMap b a  ->  (b,a)
findMax (Branch key elt _ _ EmptyFM) = (key,elt)
findMax (Branch key elt _ _ fm_r) = findMax fm_r

  findMin :: FiniteMap a b  ->  (a,b)
findMin (Branch key elt _ EmptyFM _) = (key,elt)
findMin (Branch key elt _ fm_l _) = findMin fm_l

  fmToList :: FiniteMap a b  ->  [(a,b)]
fmToList fm = foldFM fmToList0 [] fm

  
fmToList0 key elt rest = (key,elt) : rest

  foldFM :: (c  ->  b  ->  a  ->  a)  ->  a  ->  FiniteMap c b  ->  a
foldFM k z EmptyFM = z
foldFM k z (Branch key elt _ fm_l fm_r) = foldFM k (k key elt (foldFM k z fm_r)) fm_l

  glueBal :: Ord a => FiniteMap a b  ->  FiniteMap a b  ->  FiniteMap a b
glueBal EmptyFM fm2 = fm2
glueBal fm1 EmptyFM = fm1
glueBal fm1 fm2 
 | sizeFM fm2 > sizeFM fm1 = 
mkBalBranch mid_key2 mid_elt2 fm1 (deleteMin fm2)
 | otherwise = 
mkBalBranch mid_key1 mid_elt1 (deleteMax fm1) fm2 where 
mid_elt1 = mid_elt10 vv2
mid_elt10 (_,mid_elt1) = mid_elt1
mid_elt2 = mid_elt20 vv3
mid_elt20 (_,mid_elt2) = mid_elt2
mid_key1 = mid_key10 vv2
mid_key10 (mid_key1,_) = mid_key1
mid_key2 = mid_key20 vv3
mid_key20 (mid_key2,_) = mid_key2
vv2 = findMax fm1
vv3 = findMin fm2

  glueVBal :: Ord a => FiniteMap a b  ->  FiniteMap a b  ->  FiniteMap a b
glueVBal EmptyFM fm2 = fm2
glueVBal fm1 EmptyFM = fm1
glueVBal fm_l@(Branch key_l elt_l _ fm_ll fm_lr) fm_r@(Branch key_r elt_r _ fm_rl fm_rr) 
 | sIZE_RATIO * size_l < size_r = 
mkBalBranch key_r elt_r (glueVBal fm_l fm_rl) fm_rr
 | sIZE_RATIO * size_r < size_l = 
mkBalBranch key_l elt_l fm_ll (glueVBal fm_lr fm_r)
 | otherwise = 
glueBal fm_l fm_r where 
size_l = sizeFM fm_l
size_r = sizeFM fm_r

  mkBalBranch :: Ord b => b  ->  a  ->  FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
mkBalBranch key elt fm_L fm_R 
 | size_l + size_r < 2 = 
mkBranch 1 key elt fm_L fm_R
 | size_r > sIZE_RATIO * size_l = 
mkBalBranch0 fm_L fm_R fm_R
 | size_l > sIZE_RATIO * size_r = 
mkBalBranch1 fm_L fm_R fm_L
 | otherwise = 
mkBranch 2 key elt fm_L fm_R where 
double_L fm_l (Branch key_r elt_r _ (Branch key_rl elt_rl _ fm_rll fm_rlr) fm_rr) = mkBranch 5 key_rl elt_rl (mkBranch 6 key elt fm_l fm_rll) (mkBranch 7 key_r elt_r fm_rlr fm_rr)
double_R (Branch key_l elt_l _ fm_ll (Branch key_lr elt_lr _ fm_lrl fm_lrr)) fm_r = mkBranch 10 key_lr elt_lr (mkBranch 11 key_l elt_l fm_ll fm_lrl) (mkBranch 12 key elt fm_lrr fm_r)
mkBalBranch0 fm_L fm_R (Branch _ _ _ fm_rl fm_rr) 
 | sizeFM fm_rl < 2 * sizeFM fm_rr = 
single_L fm_L fm_R
 | otherwise = 
double_L fm_L fm_R
mkBalBranch1 fm_L fm_R (Branch _ _ _ fm_ll fm_lr) 
 | sizeFM fm_lr < 2 * sizeFM fm_ll = 
single_R fm_L fm_R
 | otherwise = 
double_R fm_L fm_R
single_L fm_l (Branch key_r elt_r _ fm_rl fm_rr) = mkBranch 3 key_r elt_r (mkBranch 4 key elt fm_l fm_rl) fm_rr
single_R (Branch key_l elt_l _ fm_ll fm_lr) fm_r = mkBranch 8 key_l elt_l fm_ll (mkBranch 9 key elt fm_lr fm_r)
size_l = sizeFM fm_L
size_r = sizeFM fm_R

  mkBranch :: Ord b => Int  ->  b  ->  a  ->  FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
mkBranch which key elt fm_l fm_r = 
let 
result = Branch key elt (unbox (1 + left_size + right_size)) fm_l fm_r
in result
 where 
balance_ok = True
left_ok = left_ok0 fm_l key fm_l
left_ok0 fm_l key EmptyFM = True
left_ok0 fm_l key (Branch left_key _ _ _ _) = 
let 
biggest_left_key = fst (findMax fm_l)
in biggest_left_key < key
left_size = sizeFM fm_l
right_ok = right_ok0 fm_r key fm_r
right_ok0 fm_r key EmptyFM = True
right_ok0 fm_r key (Branch right_key _ _ _ _) = 
let 
smallest_right_key = fst (findMin fm_r)
in key < smallest_right_key
right_size = sizeFM fm_r
unbox :: Int  ->  Int
unbox x = x

  mkVBalBranch :: Ord b => b  ->  a  ->  FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
mkVBalBranch key elt EmptyFM fm_r = addToFM fm_r key elt
mkVBalBranch key elt fm_l EmptyFM = addToFM fm_l key elt
mkVBalBranch key elt fm_l@(Branch key_l elt_l _ fm_ll fm_lr) fm_r@(Branch key_r elt_r _ fm_rl fm_rr) 
 | sIZE_RATIO * size_l < size_r = 
mkBalBranch key_r elt_r (mkVBalBranch key elt fm_l fm_rl) fm_rr
 | sIZE_RATIO * size_r < size_l = 
mkBalBranch key_l elt_l fm_ll (mkVBalBranch key elt fm_lr fm_r)
 | otherwise = 
mkBranch 13 key elt fm_l fm_r where 
size_l = sizeFM fm_l
size_r = sizeFM fm_r

  sIZE_RATIO :: Int
sIZE_RATIO = 5

  sizeFM :: FiniteMap a b  ->  Int
sizeFM EmptyFM = 0
sizeFM (Branch _ _ size _ _) = size

  unitFM :: a  ->  b  ->  FiniteMap a b
unitFM key elt = Branch key elt 1 emptyFM emptyFM


module Maybe where
  import qualified FiniteMap
import qualified Prelude


If Reductions:
The following If expression
if primGEqNatS x y then Succ (primDivNatS (primMinusNatS x y) (Succ y)) else Zero

is transformed to
primDivNatS0 x y True = Succ (primDivNatS (primMinusNatS x y) (Succ y))
primDivNatS0 x y False = Zero

The following If expression
if primGEqNatS x y then primModNatS (primMinusNatS x y) (Succ y) else Succ x

is transformed to
primModNatS0 x y True = primModNatS (primMinusNatS x y) (Succ y)
primModNatS0 x y False = Succ x



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR

mainModule FiniteMap
  ((filterFM :: Ord b => (b  ->  a  ->  Bool)  ->  FiniteMap b a  ->  FiniteMap b a) :: Ord b => (b  ->  a  ->  Bool)  ->  FiniteMap b a  ->  FiniteMap b a)

module FiniteMap where
  import qualified Maybe
import qualified Prelude
  data FiniteMap b a = EmptyFM  | Branch b a Int (FiniteMap b a) (FiniteMap b a) 
  instance (Eq a, Eq b) => Eq (FiniteMap a b) where 
   
(==) fm_1 fm_2 = sizeFM fm_1 == sizeFM fm_2 && fmToList fm_1 == fmToList fm_2

  addToFM :: Ord a => FiniteMap a b  ->  a  ->  b  ->  FiniteMap a b
addToFM fm key elt = addToFM_C addToFM0 fm key elt

  
addToFM0 old new = new

  addToFM_C :: Ord b => (a  ->  a  ->  a)  ->  FiniteMap b a  ->  b  ->  a  ->  FiniteMap b a
addToFM_C combiner EmptyFM key elt = unitFM key elt
addToFM_C combiner (Branch key elt size fm_l fm_r) new_key new_elt 
 | new_key < key = 
mkBalBranch key elt (addToFM_C combiner fm_l new_key new_elt) fm_r
 | new_key > key = 
mkBalBranch key elt fm_l (addToFM_C combiner fm_r new_key new_elt)
 | otherwise = 
Branch new_key (combiner elt new_elt) size fm_l fm_r

  deleteMax :: Ord b => FiniteMap b a  ->  FiniteMap b a
deleteMax (Branch key elt _ fm_l EmptyFM) = fm_l
deleteMax (Branch key elt _ fm_l fm_r) = mkBalBranch key elt fm_l (deleteMax fm_r)

  deleteMin :: Ord b => FiniteMap b a  ->  FiniteMap b a
deleteMin (Branch key elt _ EmptyFM fm_r) = fm_r
deleteMin (Branch key elt _ fm_l fm_r) = mkBalBranch key elt (deleteMin fm_l) fm_r

  emptyFM :: FiniteMap b a
emptyFM = EmptyFM

  filterFM :: Ord b => (b  ->  a  ->  Bool)  ->  FiniteMap b a  ->  FiniteMap b a
filterFM p EmptyFM = emptyFM
filterFM p (Branch key elt _ fm_l fm_r) 
 | p key elt = 
mkVBalBranch key elt (filterFM p fm_l) (filterFM p fm_r)
 | otherwise = 
glueVBal (filterFM p fm_l) (filterFM p fm_r)

  findMax :: FiniteMap a b  ->  (a,b)
findMax (Branch key elt _ _ EmptyFM) = (key,elt)
findMax (Branch key elt _ _ fm_r) = findMax fm_r

  findMin :: FiniteMap b a  ->  (b,a)
findMin (Branch key elt _ EmptyFM _) = (key,elt)
findMin (Branch key elt _ fm_l _) = findMin fm_l

  fmToList :: FiniteMap b a  ->  [(b,a)]
fmToList fm = foldFM fmToList0 [] fm

  
fmToList0 key elt rest = (key,elt) : rest

  foldFM :: (c  ->  b  ->  a  ->  a)  ->  a  ->  FiniteMap c b  ->  a
foldFM k z EmptyFM = z
foldFM k z (Branch key elt _ fm_l fm_r) = foldFM k (k key elt (foldFM k z fm_r)) fm_l

  glueBal :: Ord b => FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
glueBal EmptyFM fm2 = fm2
glueBal fm1 EmptyFM = fm1
glueBal fm1 fm2 
 | sizeFM fm2 > sizeFM fm1 = 
mkBalBranch mid_key2 mid_elt2 fm1 (deleteMin fm2)
 | otherwise = 
mkBalBranch mid_key1 mid_elt1 (deleteMax fm1) fm2 where 
mid_elt1 = mid_elt10 vv2
mid_elt10 (_,mid_elt1) = mid_elt1
mid_elt2 = mid_elt20 vv3
mid_elt20 (_,mid_elt2) = mid_elt2
mid_key1 = mid_key10 vv2
mid_key10 (mid_key1,_) = mid_key1
mid_key2 = mid_key20 vv3
mid_key20 (mid_key2,_) = mid_key2
vv2 = findMax fm1
vv3 = findMin fm2

  glueVBal :: Ord b => FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
glueVBal EmptyFM fm2 = fm2
glueVBal fm1 EmptyFM = fm1
glueVBal fm_l@(Branch key_l elt_l _ fm_ll fm_lr) fm_r@(Branch key_r elt_r _ fm_rl fm_rr) 
 | sIZE_RATIO * size_l < size_r = 
mkBalBranch key_r elt_r (glueVBal fm_l fm_rl) fm_rr
 | sIZE_RATIO * size_r < size_l = 
mkBalBranch key_l elt_l fm_ll (glueVBal fm_lr fm_r)
 | otherwise = 
glueBal fm_l fm_r where 
size_l = sizeFM fm_l
size_r = sizeFM fm_r

  mkBalBranch :: Ord b => b  ->  a  ->  FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
mkBalBranch key elt fm_L fm_R 
 | size_l + size_r < 2 = 
mkBranch 1 key elt fm_L fm_R
 | size_r > sIZE_RATIO * size_l = 
mkBalBranch0 fm_L fm_R fm_R
 | size_l > sIZE_RATIO * size_r = 
mkBalBranch1 fm_L fm_R fm_L
 | otherwise = 
mkBranch 2 key elt fm_L fm_R where 
double_L fm_l (Branch key_r elt_r _ (Branch key_rl elt_rl _ fm_rll fm_rlr) fm_rr) = mkBranch 5 key_rl elt_rl (mkBranch 6 key elt fm_l fm_rll) (mkBranch 7 key_r elt_r fm_rlr fm_rr)
double_R (Branch key_l elt_l _ fm_ll (Branch key_lr elt_lr _ fm_lrl fm_lrr)) fm_r = mkBranch 10 key_lr elt_lr (mkBranch 11 key_l elt_l fm_ll fm_lrl) (mkBranch 12 key elt fm_lrr fm_r)
mkBalBranch0 fm_L fm_R (Branch _ _ _ fm_rl fm_rr) 
 | sizeFM fm_rl < 2 * sizeFM fm_rr = 
single_L fm_L fm_R
 | otherwise = 
double_L fm_L fm_R
mkBalBranch1 fm_L fm_R (Branch _ _ _ fm_ll fm_lr) 
 | sizeFM fm_lr < 2 * sizeFM fm_ll = 
single_R fm_L fm_R
 | otherwise = 
double_R fm_L fm_R
single_L fm_l (Branch key_r elt_r _ fm_rl fm_rr) = mkBranch 3 key_r elt_r (mkBranch 4 key elt fm_l fm_rl) fm_rr
single_R (Branch key_l elt_l _ fm_ll fm_lr) fm_r = mkBranch 8 key_l elt_l fm_ll (mkBranch 9 key elt fm_lr fm_r)
size_l = sizeFM fm_L
size_r = sizeFM fm_R

  mkBranch :: Ord a => Int  ->  a  ->  b  ->  FiniteMap a b  ->  FiniteMap a b  ->  FiniteMap a b
mkBranch which key elt fm_l fm_r = 
let 
result = Branch key elt (unbox (1 + left_size + right_size)) fm_l fm_r
in result
 where 
balance_ok = True
left_ok = left_ok0 fm_l key fm_l
left_ok0 fm_l key EmptyFM = True
left_ok0 fm_l key (Branch left_key _ _ _ _) = 
let 
biggest_left_key = fst (findMax fm_l)
in biggest_left_key < key
left_size = sizeFM fm_l
right_ok = right_ok0 fm_r key fm_r
right_ok0 fm_r key EmptyFM = True
right_ok0 fm_r key (Branch right_key _ _ _ _) = 
let 
smallest_right_key = fst (findMin fm_r)
in key < smallest_right_key
right_size = sizeFM fm_r
unbox :: Int  ->  Int
unbox x = x

  mkVBalBranch :: Ord a => a  ->  b  ->  FiniteMap a b  ->  FiniteMap a b  ->  FiniteMap a b
mkVBalBranch key elt EmptyFM fm_r = addToFM fm_r key elt
mkVBalBranch key elt fm_l EmptyFM = addToFM fm_l key elt
mkVBalBranch key elt fm_l@(Branch key_l elt_l _ fm_ll fm_lr) fm_r@(Branch key_r elt_r _ fm_rl fm_rr) 
 | sIZE_RATIO * size_l < size_r = 
mkBalBranch key_r elt_r (mkVBalBranch key elt fm_l fm_rl) fm_rr
 | sIZE_RATIO * size_r < size_l = 
mkBalBranch key_l elt_l fm_ll (mkVBalBranch key elt fm_lr fm_r)
 | otherwise = 
mkBranch 13 key elt fm_l fm_r where 
size_l = sizeFM fm_l
size_r = sizeFM fm_r

  sIZE_RATIO :: Int
sIZE_RATIO = 5

  sizeFM :: FiniteMap a b  ->  Int
sizeFM EmptyFM = 0
sizeFM (Branch _ _ size _ _) = size

  unitFM :: b  ->  a  ->  FiniteMap b a
unitFM key elt = Branch key elt 1 emptyFM emptyFM


module Maybe where
  import qualified FiniteMap
import qualified Prelude


Replaced joker patterns by fresh variables and removed binding patterns.
Binding Reductions:
The bind variable of the following binding Pattern
fm_l@(Branch yw yx yy yz zu)

is replaced by the following term
Branch yw yx yy yz zu

The bind variable of the following binding Pattern
fm_r@(Branch zw zx zy zz vuu)

is replaced by the following term
Branch zw zx zy zz vuu

The bind variable of the following binding Pattern
fm_l@(Branch vuy vuz vvu vvv vvw)

is replaced by the following term
Branch vuy vuz vvu vvv vvw

The bind variable of the following binding Pattern
fm_r@(Branch vvy vvz vwu vwv vww)

is replaced by the following term
Branch vvy vvz vwu vwv vww



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR

mainModule FiniteMap
  ((filterFM :: Ord b => (b  ->  a  ->  Bool)  ->  FiniteMap b a  ->  FiniteMap b a) :: Ord b => (b  ->  a  ->  Bool)  ->  FiniteMap b a  ->  FiniteMap b a)

module FiniteMap where
  import qualified Maybe
import qualified Prelude
  data FiniteMap b a = EmptyFM  | Branch b a Int (FiniteMap b a) (FiniteMap b a) 
  instance (Eq a, Eq b) => Eq (FiniteMap a b) where 
   
(==) fm_1 fm_2 = sizeFM fm_1 == sizeFM fm_2 && fmToList fm_1 == fmToList fm_2

  addToFM :: Ord b => FiniteMap b a  ->  b  ->  a  ->  FiniteMap b a
addToFM fm key elt = addToFM_C addToFM0 fm key elt

  
addToFM0 old new = new

  addToFM_C :: Ord a => (b  ->  b  ->  b)  ->  FiniteMap a b  ->  a  ->  b  ->  FiniteMap a b
addToFM_C combiner EmptyFM key elt = unitFM key elt
addToFM_C combiner (Branch key elt size fm_l fm_r) new_key new_elt 
 | new_key < key = 
mkBalBranch key elt (addToFM_C combiner fm_l new_key new_elt) fm_r
 | new_key > key = 
mkBalBranch key elt fm_l (addToFM_C combiner fm_r new_key new_elt)
 | otherwise = 
Branch new_key (combiner elt new_elt) size fm_l fm_r

  deleteMax :: Ord a => FiniteMap a b  ->  FiniteMap a b
deleteMax (Branch key elt vuv fm_l EmptyFM) = fm_l
deleteMax (Branch key elt vuw fm_l fm_r) = mkBalBranch key elt fm_l (deleteMax fm_r)

  deleteMin :: Ord a => FiniteMap a b  ->  FiniteMap a b
deleteMin (Branch key elt vzz EmptyFM fm_r) = fm_r
deleteMin (Branch key elt wuu fm_l fm_r) = mkBalBranch key elt (deleteMin fm_l) fm_r

  emptyFM :: FiniteMap a b
emptyFM = EmptyFM

  filterFM :: Ord a => (a  ->  b  ->  Bool)  ->  FiniteMap a b  ->  FiniteMap a b
filterFM p EmptyFM = emptyFM
filterFM p (Branch key elt wuv fm_l fm_r) 
 | p key elt = 
mkVBalBranch key elt (filterFM p fm_l) (filterFM p fm_r)
 | otherwise = 
glueVBal (filterFM p fm_l) (filterFM p fm_r)

  findMax :: FiniteMap b a  ->  (b,a)
findMax (Branch key elt vzv vzw EmptyFM) = (key,elt)
findMax (Branch key elt vzx vzy fm_r) = findMax fm_r

  findMin :: FiniteMap a b  ->  (a,b)
findMin (Branch key elt wz EmptyFM xu) = (key,elt)
findMin (Branch key elt xv fm_l xw) = findMin fm_l

  fmToList :: FiniteMap a b  ->  [(a,b)]
fmToList fm = foldFM fmToList0 [] fm

  
fmToList0 key elt rest = (key,elt) : rest

  foldFM :: (b  ->  a  ->  c  ->  c)  ->  c  ->  FiniteMap b a  ->  c
foldFM k z EmptyFM = z
foldFM k z (Branch key elt wy fm_l fm_r) = foldFM k (k key elt (foldFM k z fm_r)) fm_l

  glueBal :: Ord a => FiniteMap a b  ->  FiniteMap a b  ->  FiniteMap a b
glueBal EmptyFM fm2 = fm2
glueBal fm1 EmptyFM = fm1
glueBal fm1 fm2 
 | sizeFM fm2 > sizeFM fm1 = 
mkBalBranch mid_key2 mid_elt2 fm1 (deleteMin fm2)
 | otherwise = 
mkBalBranch mid_key1 mid_elt1 (deleteMax fm1) fm2 where 
mid_elt1 = mid_elt10 vv2
mid_elt10 (vyx,mid_elt1) = mid_elt1
mid_elt2 = mid_elt20 vv3
mid_elt20 (vyy,mid_elt2) = mid_elt2
mid_key1 = mid_key10 vv2
mid_key10 (mid_key1,vyz) = mid_key1
mid_key2 = mid_key20 vv3
mid_key20 (mid_key2,vzu) = mid_key2
vv2 = findMax fm1
vv3 = findMin fm2

  glueVBal :: Ord b => FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
glueVBal EmptyFM fm2 = fm2
glueVBal fm1 EmptyFM = fm1
glueVBal (Branch yw yx yy yz zu) (Branch zw zx zy zz vuu) 
 | sIZE_RATIO * size_l < size_r = 
mkBalBranch zw zx (glueVBal (Branch yw yx yy yz zu) zz) vuu
 | sIZE_RATIO * size_r < size_l = 
mkBalBranch yw yx yz (glueVBal zu (Branch zw zx zy zz vuu))
 | otherwise = 
glueBal (Branch yw yx yy yz zu) (Branch zw zx zy zz vuu) where 
size_l = sizeFM (Branch yw yx yy yz zu)
size_r = sizeFM (Branch zw zx zy zz vuu)

  mkBalBranch :: Ord a => a  ->  b  ->  FiniteMap a b  ->  FiniteMap a b  ->  FiniteMap a b
mkBalBranch key elt fm_L fm_R 
 | size_l + size_r < 2 = 
mkBranch 1 key elt fm_L fm_R
 | size_r > sIZE_RATIO * size_l = 
mkBalBranch0 fm_L fm_R fm_R
 | size_l > sIZE_RATIO * size_r = 
mkBalBranch1 fm_L fm_R fm_L
 | otherwise = 
mkBranch 2 key elt fm_L fm_R where 
double_L fm_l (Branch key_r elt_r vxx (Branch key_rl elt_rl vxy fm_rll fm_rlr) fm_rr) = mkBranch 5 key_rl elt_rl (mkBranch 6 key elt fm_l fm_rll) (mkBranch 7 key_r elt_r fm_rlr fm_rr)
double_R (Branch key_l elt_l vwy fm_ll (Branch key_lr elt_lr vwz fm_lrl fm_lrr)) fm_r = mkBranch 10 key_lr elt_lr (mkBranch 11 key_l elt_l fm_ll fm_lrl) (mkBranch 12 key elt fm_lrr fm_r)
mkBalBranch0 fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr) 
 | sizeFM fm_rl < 2 * sizeFM fm_rr = 
single_L fm_L fm_R
 | otherwise = 
double_L fm_L fm_R
mkBalBranch1 fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr) 
 | sizeFM fm_lr < 2 * sizeFM fm_ll = 
single_R fm_L fm_R
 | otherwise = 
double_R fm_L fm_R
single_L fm_l (Branch key_r elt_r vyw fm_rl fm_rr) = mkBranch 3 key_r elt_r (mkBranch 4 key elt fm_l fm_rl) fm_rr
single_R (Branch key_l elt_l vwx fm_ll fm_lr) fm_r = mkBranch 8 key_l elt_l fm_ll (mkBranch 9 key elt fm_lr fm_r)
size_l = sizeFM fm_L
size_r = sizeFM fm_R

  mkBranch :: Ord b => Int  ->  b  ->  a  ->  FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
mkBranch which key elt fm_l fm_r = 
let 
result = Branch key elt (unbox (1 + left_size + right_size)) fm_l fm_r
in result
 where 
balance_ok = True
left_ok = left_ok0 fm_l key fm_l
left_ok0 fm_l key EmptyFM = True
left_ok0 fm_l key (Branch left_key vw vx vy vz) = 
let 
biggest_left_key = fst (findMax fm_l)
in biggest_left_key < key
left_size = sizeFM fm_l
right_ok = right_ok0 fm_r key fm_r
right_ok0 fm_r key EmptyFM = True
right_ok0 fm_r key (Branch right_key wu wv ww wx) = 
let 
smallest_right_key = fst (findMin fm_r)
in key < smallest_right_key
right_size = sizeFM fm_r
unbox :: Int  ->  Int
unbox x = x

  mkVBalBranch :: Ord b => b  ->  a  ->  FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
mkVBalBranch key elt EmptyFM fm_r = addToFM fm_r key elt
mkVBalBranch key elt fm_l EmptyFM = addToFM fm_l key elt
mkVBalBranch key elt (Branch vuy vuz vvu vvv vvw) (Branch vvy vvz vwu vwv vww) 
 | sIZE_RATIO * size_l < size_r = 
mkBalBranch vvy vvz (mkVBalBranch key elt (Branch vuy vuz vvu vvv vvw) vwv) vww
 | sIZE_RATIO * size_r < size_l = 
mkBalBranch vuy vuz vvv (mkVBalBranch key elt vvw (Branch vvy vvz vwu vwv vww))
 | otherwise = 
mkBranch 13 key elt (Branch vuy vuz vvu vvv vvw) (Branch vvy vvz vwu vwv vww) where 
size_l = sizeFM (Branch vuy vuz vvu vvv vvw)
size_r = sizeFM (Branch vvy vvz vwu vwv vww)

  sIZE_RATIO :: Int
sIZE_RATIO = 5

  sizeFM :: FiniteMap a b  ->  Int
sizeFM EmptyFM = 0
sizeFM (Branch xx xy size xz yu) = size

  unitFM :: a  ->  b  ->  FiniteMap a b
unitFM key elt = Branch key elt 1 emptyFM emptyFM


module Maybe where
  import qualified FiniteMap
import qualified Prelude


Cond Reductions:
The following Function with conditions
glueVBal EmptyFM fm2 = fm2
glueVBal fm1 EmptyFM = fm1
glueVBal (Branch yw yx yy yz zu) (Branch zw zx zy zz vuu)
 | sIZE_RATIO * size_l < size_r
 = mkBalBranch zw zx (glueVBal (Branch yw yx yy yz zu) zz) vuu
 | sIZE_RATIO * size_r < size_l
 = mkBalBranch yw yx yz (glueVBal zu (Branch zw zx zy zz vuu))
 | otherwise
 = glueBal (Branch yw yx yy yz zu) (Branch zw zx zy zz vuu)
where 
size_l  = sizeFM (Branch yw yx yy yz zu)
size_r  = sizeFM (Branch zw zx zy zz vuu)

is transformed to
glueVBal EmptyFM fm2 = glueVBal5 EmptyFM fm2
glueVBal fm1 EmptyFM = glueVBal4 fm1 EmptyFM
glueVBal (Branch yw yx yy yz zu) (Branch zw zx zy zz vuu) = glueVBal3 (Branch yw yx yy yz zu) (Branch zw zx zy zz vuu)

glueVBal3 (Branch yw yx yy yz zu) (Branch zw zx zy zz vuu) = 
glueVBal2 yw yx yy yz zu zw zx zy zz vuu (sIZE_RATIO * size_l < size_r)
where 
glueVBal0 yw yx yy yz zu zw zx zy zz vuu True = glueBal (Branch yw yx yy yz zu) (Branch zw zx zy zz vuu)
glueVBal1 yw yx yy yz zu zw zx zy zz vuu True = mkBalBranch yw yx yz (glueVBal zu (Branch zw zx zy zz vuu))
glueVBal1 yw yx yy yz zu zw zx zy zz vuu False = glueVBal0 yw yx yy yz zu zw zx zy zz vuu otherwise
glueVBal2 yw yx yy yz zu zw zx zy zz vuu True = mkBalBranch zw zx (glueVBal (Branch yw yx yy yz zu) zz) vuu
glueVBal2 yw yx yy yz zu zw zx zy zz vuu False = glueVBal1 yw yx yy yz zu zw zx zy zz vuu (sIZE_RATIO * size_r < size_l)
size_l  = sizeFM (Branch yw yx yy yz zu)
size_r  = sizeFM (Branch zw zx zy zz vuu)

glueVBal4 fm1 EmptyFM = fm1
glueVBal4 wzw wzx = glueVBal3 wzw wzx

glueVBal5 EmptyFM fm2 = fm2
glueVBal5 wzz xuu = glueVBal4 wzz xuu

The following Function with conditions
mkVBalBranch key elt EmptyFM fm_r = addToFM fm_r key elt
mkVBalBranch key elt fm_l EmptyFM = addToFM fm_l key elt
mkVBalBranch key elt (Branch vuy vuz vvu vvv vvw) (Branch vvy vvz vwu vwv vww)
 | sIZE_RATIO * size_l < size_r
 = mkBalBranch vvy vvz (mkVBalBranch key elt (Branch vuy vuz vvu vvv vvw) vwv) vww
 | sIZE_RATIO * size_r < size_l
 = mkBalBranch vuy vuz vvv (mkVBalBranch key elt vvw (Branch vvy vvz vwu vwv vww))
 | otherwise
 = mkBranch 13 key elt (Branch vuy vuz vvu vvv vvw) (Branch vvy vvz vwu vwv vww)
where 
size_l  = sizeFM (Branch vuy vuz vvu vvv vvw)
size_r  = sizeFM (Branch vvy vvz vwu vwv vww)

is transformed to
mkVBalBranch key elt EmptyFM fm_r = mkVBalBranch5 key elt EmptyFM fm_r
mkVBalBranch key elt fm_l EmptyFM = mkVBalBranch4 key elt fm_l EmptyFM
mkVBalBranch key elt (Branch vuy vuz vvu vvv vvw) (Branch vvy vvz vwu vwv vww) = mkVBalBranch3 key elt (Branch vuy vuz vvu vvv vvw) (Branch vvy vvz vwu vwv vww)

mkVBalBranch3 key elt (Branch vuy vuz vvu vvv vvw) (Branch vvy vvz vwu vwv vww) = 
mkVBalBranch2 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww (sIZE_RATIO * size_l < size_r)
where 
mkVBalBranch0 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww True = mkBranch 13 key elt (Branch vuy vuz vvu vvv vvw) (Branch vvy vvz vwu vwv vww)
mkVBalBranch1 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww True = mkBalBranch vuy vuz vvv (mkVBalBranch key elt vvw (Branch vvy vvz vwu vwv vww))
mkVBalBranch1 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww False = mkVBalBranch0 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww otherwise
mkVBalBranch2 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww True = mkBalBranch vvy vvz (mkVBalBranch key elt (Branch vuy vuz vvu vvv vvw) vwv) vww
mkVBalBranch2 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww False = mkVBalBranch1 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww (sIZE_RATIO * size_r < size_l)
size_l  = sizeFM (Branch vuy vuz vvu vvv vvw)
size_r  = sizeFM (Branch vvy vvz vwu vwv vww)

mkVBalBranch4 key elt fm_l EmptyFM = addToFM fm_l key elt
mkVBalBranch4 xuy xuz xvu xvv = mkVBalBranch3 xuy xuz xvu xvv

mkVBalBranch5 key elt EmptyFM fm_r = addToFM fm_r key elt
mkVBalBranch5 xvx xvy xvz xwu = mkVBalBranch4 xvx xvy xvz xwu

The following Function with conditions
mkBalBranch1 fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr)
 | sizeFM fm_lr < 2 * sizeFM fm_ll
 = single_R fm_L fm_R
 | otherwise
 = double_R fm_L fm_R

is transformed to
mkBalBranch1 fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr) = mkBalBranch12 fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr)

mkBalBranch10 fm_L fm_R vxu vxv vxw fm_ll fm_lr True = double_R fm_L fm_R

mkBalBranch11 fm_L fm_R vxu vxv vxw fm_ll fm_lr True = single_R fm_L fm_R
mkBalBranch11 fm_L fm_R vxu vxv vxw fm_ll fm_lr False = mkBalBranch10 fm_L fm_R vxu vxv vxw fm_ll fm_lr otherwise

mkBalBranch12 fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr) = mkBalBranch11 fm_L fm_R vxu vxv vxw fm_ll fm_lr (sizeFM fm_lr < 2 * sizeFM fm_ll)

The following Function with conditions
mkBalBranch0 fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr)
 | sizeFM fm_rl < 2 * sizeFM fm_rr
 = single_L fm_L fm_R
 | otherwise
 = double_L fm_L fm_R

is transformed to
mkBalBranch0 fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr) = mkBalBranch02 fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr)

mkBalBranch01 fm_L fm_R vxz vyu vyv fm_rl fm_rr True = single_L fm_L fm_R
mkBalBranch01 fm_L fm_R vxz vyu vyv fm_rl fm_rr False = mkBalBranch00 fm_L fm_R vxz vyu vyv fm_rl fm_rr otherwise

mkBalBranch00 fm_L fm_R vxz vyu vyv fm_rl fm_rr True = double_L fm_L fm_R

mkBalBranch02 fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr) = mkBalBranch01 fm_L fm_R vxz vyu vyv fm_rl fm_rr (sizeFM fm_rl < 2 * sizeFM fm_rr)

The following Function with conditions
mkBalBranch key elt fm_L fm_R
 | size_l + size_r < 2
 = mkBranch 1 key elt fm_L fm_R
 | size_r > sIZE_RATIO * size_l
 = mkBalBranch0 fm_L fm_R fm_R
 | size_l > sIZE_RATIO * size_r
 = mkBalBranch1 fm_L fm_R fm_L
 | otherwise
 = mkBranch 2 key elt fm_L fm_R
where 
double_L fm_l (Branch key_r elt_r vxx (Branch key_rl elt_rl vxy fm_rll fm_rlr) fm_rr) = mkBranch 5 key_rl elt_rl (mkBranch 6 key elt fm_l fm_rll) (mkBranch 7 key_r elt_r fm_rlr fm_rr)
double_R (Branch key_l elt_l vwy fm_ll (Branch key_lr elt_lr vwz fm_lrl fm_lrr)) fm_r = mkBranch 10 key_lr elt_lr (mkBranch 11 key_l elt_l fm_ll fm_lrl) (mkBranch 12 key elt fm_lrr fm_r)
mkBalBranch0 fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr)
 | sizeFM fm_rl < 2 * sizeFM fm_rr
 = single_L fm_L fm_R
 | otherwise
 = double_L fm_L fm_R
mkBalBranch1 fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr)
 | sizeFM fm_lr < 2 * sizeFM fm_ll
 = single_R fm_L fm_R
 | otherwise
 = double_R fm_L fm_R
single_L fm_l (Branch key_r elt_r vyw fm_rl fm_rr) = mkBranch 3 key_r elt_r (mkBranch 4 key elt fm_l fm_rl) fm_rr
single_R (Branch key_l elt_l vwx fm_ll fm_lr) fm_r = mkBranch 8 key_l elt_l fm_ll (mkBranch 9 key elt fm_lr fm_r)
size_l  = sizeFM fm_L
size_r  = sizeFM fm_R

is transformed to
mkBalBranch key elt fm_L fm_R = mkBalBranch6 key elt fm_L fm_R

mkBalBranch6 key elt fm_L fm_R = 
mkBalBranch5 key elt fm_L fm_R (size_l + size_r < 2)
where 
double_L fm_l (Branch key_r elt_r vxx (Branch key_rl elt_rl vxy fm_rll fm_rlr) fm_rr) = mkBranch 5 key_rl elt_rl (mkBranch 6 key elt fm_l fm_rll) (mkBranch 7 key_r elt_r fm_rlr fm_rr)
double_R (Branch key_l elt_l vwy fm_ll (Branch key_lr elt_lr vwz fm_lrl fm_lrr)) fm_r = mkBranch 10 key_lr elt_lr (mkBranch 11 key_l elt_l fm_ll fm_lrl) (mkBranch 12 key elt fm_lrr fm_r)
mkBalBranch0 fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr) = mkBalBranch02 fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr)
mkBalBranch00 fm_L fm_R vxz vyu vyv fm_rl fm_rr True = double_L fm_L fm_R
mkBalBranch01 fm_L fm_R vxz vyu vyv fm_rl fm_rr True = single_L fm_L fm_R
mkBalBranch01 fm_L fm_R vxz vyu vyv fm_rl fm_rr False = mkBalBranch00 fm_L fm_R vxz vyu vyv fm_rl fm_rr otherwise
mkBalBranch02 fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr) = mkBalBranch01 fm_L fm_R vxz vyu vyv fm_rl fm_rr (sizeFM fm_rl < 2 * sizeFM fm_rr)
mkBalBranch1 fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr) = mkBalBranch12 fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr)
mkBalBranch10 fm_L fm_R vxu vxv vxw fm_ll fm_lr True = double_R fm_L fm_R
mkBalBranch11 fm_L fm_R vxu vxv vxw fm_ll fm_lr True = single_R fm_L fm_R
mkBalBranch11 fm_L fm_R vxu vxv vxw fm_ll fm_lr False = mkBalBranch10 fm_L fm_R vxu vxv vxw fm_ll fm_lr otherwise
mkBalBranch12 fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr) = mkBalBranch11 fm_L fm_R vxu vxv vxw fm_ll fm_lr (sizeFM fm_lr < 2 * sizeFM fm_ll)
mkBalBranch2 key elt fm_L fm_R True = mkBranch 2 key elt fm_L fm_R
mkBalBranch3 key elt fm_L fm_R True = mkBalBranch1 fm_L fm_R fm_L
mkBalBranch3 key elt fm_L fm_R False = mkBalBranch2 key elt fm_L fm_R otherwise
mkBalBranch4 key elt fm_L fm_R True = mkBalBranch0 fm_L fm_R fm_R
mkBalBranch4 key elt fm_L fm_R False = mkBalBranch3 key elt fm_L fm_R (size_l > sIZE_RATIO * size_r)
mkBalBranch5 key elt fm_L fm_R True = mkBranch 1 key elt fm_L fm_R
mkBalBranch5 key elt fm_L fm_R False = mkBalBranch4 key elt fm_L fm_R (size_r > sIZE_RATIO * size_l)
single_L fm_l (Branch key_r elt_r vyw fm_rl fm_rr) = mkBranch 3 key_r elt_r (mkBranch 4 key elt fm_l fm_rl) fm_rr
single_R (Branch key_l elt_l vwx fm_ll fm_lr) fm_r = mkBranch 8 key_l elt_l fm_ll (mkBranch 9 key elt fm_lr fm_r)
size_l  = sizeFM fm_L
size_r  = sizeFM fm_R

The following Function with conditions
glueBal EmptyFM fm2 = fm2
glueBal fm1 EmptyFM = fm1
glueBal fm1 fm2
 | sizeFM fm2 > sizeFM fm1
 = mkBalBranch mid_key2 mid_elt2 fm1 (deleteMin fm2)
 | otherwise
 = mkBalBranch mid_key1 mid_elt1 (deleteMax fm1) fm2
where 
mid_elt1  = mid_elt10 vv2
mid_elt10 (vyx,mid_elt1) = mid_elt1
mid_elt2  = mid_elt20 vv3
mid_elt20 (vyy,mid_elt2) = mid_elt2
mid_key1  = mid_key10 vv2
mid_key10 (mid_key1,vyz) = mid_key1
mid_key2  = mid_key20 vv3
mid_key20 (mid_key2,vzu) = mid_key2
vv2  = findMax fm1
vv3  = findMin fm2

is transformed to
glueBal EmptyFM fm2 = glueBal4 EmptyFM fm2
glueBal fm1 EmptyFM = glueBal3 fm1 EmptyFM
glueBal fm1 fm2 = glueBal2 fm1 fm2

glueBal2 fm1 fm2 = 
glueBal1 fm1 fm2 (sizeFM fm2 > sizeFM fm1)
where 
glueBal0 fm1 fm2 True = mkBalBranch mid_key1 mid_elt1 (deleteMax fm1) fm2
glueBal1 fm1 fm2 True = mkBalBranch mid_key2 mid_elt2 fm1 (deleteMin fm2)
glueBal1 fm1 fm2 False = glueBal0 fm1 fm2 otherwise
mid_elt1  = mid_elt10 vv2
mid_elt10 (vyx,mid_elt1) = mid_elt1
mid_elt2  = mid_elt20 vv3
mid_elt20 (vyy,mid_elt2) = mid_elt2
mid_key1  = mid_key10 vv2
mid_key10 (mid_key1,vyz) = mid_key1
mid_key2  = mid_key20 vv3
mid_key20 (mid_key2,vzu) = mid_key2
vv2  = findMax fm1
vv3  = findMin fm2

glueBal3 fm1 EmptyFM = fm1
glueBal3 xwy xwz = glueBal2 xwy xwz

glueBal4 EmptyFM fm2 = fm2
glueBal4 xxv xxw = glueBal3 xxv xxw

The following Function with conditions
addToFM_C combiner EmptyFM key elt = unitFM key elt
addToFM_C combiner (Branch key elt size fm_l fm_r) new_key new_elt
 | new_key < key
 = mkBalBranch key elt (addToFM_C combiner fm_l new_key new_elt) fm_r
 | new_key > key
 = mkBalBranch key elt fm_l (addToFM_C combiner fm_r new_key new_elt)
 | otherwise
 = Branch new_key (combiner elt new_elt) size fm_l fm_r

is transformed to
addToFM_C combiner EmptyFM key elt = addToFM_C4 combiner EmptyFM key elt
addToFM_C combiner (Branch key elt size fm_l fm_r) new_key new_elt = addToFM_C3 combiner (Branch key elt size fm_l fm_r) new_key new_elt

addToFM_C1 combiner key elt size fm_l fm_r new_key new_elt True = mkBalBranch key elt fm_l (addToFM_C combiner fm_r new_key new_elt)
addToFM_C1 combiner key elt size fm_l fm_r new_key new_elt False = addToFM_C0 combiner key elt size fm_l fm_r new_key new_elt otherwise

addToFM_C0 combiner key elt size fm_l fm_r new_key new_elt True = Branch new_key (combiner elt new_elt) size fm_l fm_r

addToFM_C2 combiner key elt size fm_l fm_r new_key new_elt True = mkBalBranch key elt (addToFM_C combiner fm_l new_key new_elt) fm_r
addToFM_C2 combiner key elt size fm_l fm_r new_key new_elt False = addToFM_C1 combiner key elt size fm_l fm_r new_key new_elt (new_key > key)

addToFM_C3 combiner (Branch key elt size fm_l fm_r) new_key new_elt = addToFM_C2 combiner key elt size fm_l fm_r new_key new_elt (new_key < key)

addToFM_C4 combiner EmptyFM key elt = unitFM key elt
addToFM_C4 xxz xyu xyv xyw = addToFM_C3 xxz xyu xyv xyw

The following Function with conditions
filterFM p EmptyFM = emptyFM
filterFM p (Branch key elt wuv fm_l fm_r)
 | p key elt
 = mkVBalBranch key elt (filterFM p fm_l) (filterFM p fm_r)
 | otherwise
 = glueVBal (filterFM p fm_l) (filterFM p fm_r)

is transformed to
filterFM p EmptyFM = filterFM3 p EmptyFM
filterFM p (Branch key elt wuv fm_l fm_r) = filterFM2 p (Branch key elt wuv fm_l fm_r)

filterFM1 p key elt wuv fm_l fm_r True = mkVBalBranch key elt (filterFM p fm_l) (filterFM p fm_r)
filterFM1 p key elt wuv fm_l fm_r False = filterFM0 p key elt wuv fm_l fm_r otherwise

filterFM0 p key elt wuv fm_l fm_r True = glueVBal (filterFM p fm_l) (filterFM p fm_r)

filterFM2 p (Branch key elt wuv fm_l fm_r) = filterFM1 p key elt wuv fm_l fm_r (p key elt)

filterFM3 p EmptyFM = emptyFM
filterFM3 xyz xzu = filterFM2 xyz xzu

The following Function with conditions
compare x y
 | x == y
 = EQ
 | x <= y
 = LT
 | otherwise
 = GT

is transformed to
compare x y = compare3 x y

compare1 x y True = LT
compare1 x y False = compare0 x y otherwise

compare2 x y True = EQ
compare2 x y False = compare1 x y (x <= y)

compare0 x y True = GT

compare3 x y = compare2 x y (x == y)

The following Function with conditions
gcd' x 0 = x
gcd' x y = gcd' y (x `rem` y)

is transformed to
gcd' x xzv = gcd'2 x xzv
gcd' x y = gcd'0 x y

gcd'0 x y = gcd' y (x `rem` y)

gcd'1 True x xzv = x
gcd'1 xzw xzx xzy = gcd'0 xzx xzy

gcd'2 x xzv = gcd'1 (xzv == 0) x xzv
gcd'2 xzz yuu = gcd'0 xzz yuu

The following Function with conditions
gcd 0 0 = error []
gcd x y = 
gcd' (abs x) (abs y)
where 
gcd' x 0 = x
gcd' x y = gcd' y (x `rem` y)

is transformed to
gcd yuv yuw = gcd3 yuv yuw
gcd x y = gcd0 x y

gcd0 x y = 
gcd' (abs x) (abs y)
where 
gcd' x xzv = gcd'2 x xzv
gcd' x y = gcd'0 x y
gcd'0 x y = gcd' y (x `rem` y)
gcd'1 True x xzv = x
gcd'1 xzw xzx xzy = gcd'0 xzx xzy
gcd'2 x xzv = gcd'1 (xzv == 0) x xzv
gcd'2 xzz yuu = gcd'0 xzz yuu

gcd1 True yuv yuw = error []
gcd1 yux yuy yuz = gcd0 yuy yuz

gcd2 True yuv yuw = gcd1 (yuw == 0) yuv yuw
gcd2 yvu yvv yvw = gcd0 yvv yvw

gcd3 yuv yuw = gcd2 (yuv == 0) yuv yuw
gcd3 yvx yvy = gcd0 yvx yvy

The following Function with conditions
absReal x
 | x >= 0
 = x
 | otherwise
 = `negate` x

is transformed to
absReal x = absReal2 x

absReal1 x True = x
absReal1 x False = absReal0 x otherwise

absReal0 x True = `negate` x

absReal2 x = absReal1 x (x >= 0)

The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False

The following Function with conditions
reduce x y
 | y == 0
 = error []
 | otherwise
 = x `quot` d :% (y `quot` d)
where 
d  = gcd x y

is transformed to
reduce x y = reduce2 x y

reduce2 x y = 
reduce1 x y (y == 0)
where 
d  = gcd x y
reduce0 x y True = x `quot` d :% (y `quot` d)
reduce1 x y True = error []
reduce1 x y False = reduce0 x y otherwise



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed

mainModule FiniteMap
  ((filterFM :: Ord b => (b  ->  a  ->  Bool)  ->  FiniteMap b a  ->  FiniteMap b a) :: Ord b => (b  ->  a  ->  Bool)  ->  FiniteMap b a  ->  FiniteMap b a)

module FiniteMap where
  import qualified Maybe
import qualified Prelude
  data FiniteMap b a = EmptyFM  | Branch b a Int (FiniteMap b a) (FiniteMap b a) 
  instance (Eq a, Eq b) => Eq (FiniteMap b a) where 
   
(==) fm_1 fm_2 = sizeFM fm_1 == sizeFM fm_2 && fmToList fm_1 == fmToList fm_2

  addToFM :: Ord a => FiniteMap a b  ->  a  ->  b  ->  FiniteMap a b
addToFM fm key elt = addToFM_C addToFM0 fm key elt

  
addToFM0 old new = new

  addToFM_C :: Ord a => (b  ->  b  ->  b)  ->  FiniteMap a b  ->  a  ->  b  ->  FiniteMap a b
addToFM_C combiner EmptyFM key elt = addToFM_C4 combiner EmptyFM key elt
addToFM_C combiner (Branch key elt size fm_l fm_r) new_key new_elt = addToFM_C3 combiner (Branch key elt size fm_l fm_r) new_key new_elt

  
addToFM_C0 combiner key elt size fm_l fm_r new_key new_elt True = Branch new_key (combiner elt new_elt) size fm_l fm_r

  
addToFM_C1 combiner key elt size fm_l fm_r new_key new_elt True = mkBalBranch key elt fm_l (addToFM_C combiner fm_r new_key new_elt)
addToFM_C1 combiner key elt size fm_l fm_r new_key new_elt False = addToFM_C0 combiner key elt size fm_l fm_r new_key new_elt otherwise

  
addToFM_C2 combiner key elt size fm_l fm_r new_key new_elt True = mkBalBranch key elt (addToFM_C combiner fm_l new_key new_elt) fm_r
addToFM_C2 combiner key elt size fm_l fm_r new_key new_elt False = addToFM_C1 combiner key elt size fm_l fm_r new_key new_elt (new_key > key)

  
addToFM_C3 combiner (Branch key elt size fm_l fm_r) new_key new_elt = addToFM_C2 combiner key elt size fm_l fm_r new_key new_elt (new_key < key)

  
addToFM_C4 combiner EmptyFM key elt = unitFM key elt
addToFM_C4 xxz xyu xyv xyw = addToFM_C3 xxz xyu xyv xyw

  deleteMax :: Ord b => FiniteMap b a  ->  FiniteMap b a
deleteMax (Branch key elt vuv fm_l EmptyFM) = fm_l
deleteMax (Branch key elt vuw fm_l fm_r) = mkBalBranch key elt fm_l (deleteMax fm_r)

  deleteMin :: Ord a => FiniteMap a b  ->  FiniteMap a b
deleteMin (Branch key elt vzz EmptyFM fm_r) = fm_r
deleteMin (Branch key elt wuu fm_l fm_r) = mkBalBranch key elt (deleteMin fm_l) fm_r

  emptyFM :: FiniteMap a b
emptyFM = EmptyFM

  filterFM :: Ord b => (b  ->  a  ->  Bool)  ->  FiniteMap b a  ->  FiniteMap b a
filterFM p EmptyFM = filterFM3 p EmptyFM
filterFM p (Branch key elt wuv fm_l fm_r) = filterFM2 p (Branch key elt wuv fm_l fm_r)

  
filterFM0 p key elt wuv fm_l fm_r True = glueVBal (filterFM p fm_l) (filterFM p fm_r)

  
filterFM1 p key elt wuv fm_l fm_r True = mkVBalBranch key elt (filterFM p fm_l) (filterFM p fm_r)
filterFM1 p key elt wuv fm_l fm_r False = filterFM0 p key elt wuv fm_l fm_r otherwise

  
filterFM2 p (Branch key elt wuv fm_l fm_r) = filterFM1 p key elt wuv fm_l fm_r (p key elt)

  
filterFM3 p EmptyFM = emptyFM
filterFM3 xyz xzu = filterFM2 xyz xzu

  findMax :: FiniteMap a b  ->  (a,b)
findMax (Branch key elt vzv vzw EmptyFM) = (key,elt)
findMax (Branch key elt vzx vzy fm_r) = findMax fm_r

  findMin :: FiniteMap b a  ->  (b,a)
findMin (Branch key elt wz EmptyFM xu) = (key,elt)
findMin (Branch key elt xv fm_l xw) = findMin fm_l

  fmToList :: FiniteMap a b  ->  [(a,b)]
fmToList fm = foldFM fmToList0 [] fm

  
fmToList0 key elt rest = (key,elt) : rest

  foldFM :: (c  ->  a  ->  b  ->  b)  ->  b  ->  FiniteMap c a  ->  b
foldFM k z EmptyFM = z
foldFM k z (Branch key elt wy fm_l fm_r) = foldFM k (k key elt (foldFM k z fm_r)) fm_l

  glueBal :: Ord b => FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
glueBal EmptyFM fm2 = glueBal4 EmptyFM fm2
glueBal fm1 EmptyFM = glueBal3 fm1 EmptyFM
glueBal fm1 fm2 = glueBal2 fm1 fm2

  
glueBal2 fm1 fm2 = 
glueBal1 fm1 fm2 (sizeFM fm2 > sizeFM fm1) where 
glueBal0 fm1 fm2 True = mkBalBranch mid_key1 mid_elt1 (deleteMax fm1) fm2
glueBal1 fm1 fm2 True = mkBalBranch mid_key2 mid_elt2 fm1 (deleteMin fm2)
glueBal1 fm1 fm2 False = glueBal0 fm1 fm2 otherwise
mid_elt1 = mid_elt10 vv2
mid_elt10 (vyx,mid_elt1) = mid_elt1
mid_elt2 = mid_elt20 vv3
mid_elt20 (vyy,mid_elt2) = mid_elt2
mid_key1 = mid_key10 vv2
mid_key10 (mid_key1,vyz) = mid_key1
mid_key2 = mid_key20 vv3
mid_key20 (mid_key2,vzu) = mid_key2
vv2 = findMax fm1
vv3 = findMin fm2

  
glueBal3 fm1 EmptyFM = fm1
glueBal3 xwy xwz = glueBal2 xwy xwz

  
glueBal4 EmptyFM fm2 = fm2
glueBal4 xxv xxw = glueBal3 xxv xxw

  glueVBal :: Ord b => FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
glueVBal EmptyFM fm2 = glueVBal5 EmptyFM fm2
glueVBal fm1 EmptyFM = glueVBal4 fm1 EmptyFM
glueVBal (Branch yw yx yy yz zu) (Branch zw zx zy zz vuu) = glueVBal3 (Branch yw yx yy yz zu) (Branch zw zx zy zz vuu)

  
glueVBal3 (Branch yw yx yy yz zu) (Branch zw zx zy zz vuu) = 
glueVBal2 yw yx yy yz zu zw zx zy zz vuu (sIZE_RATIO * size_l < size_r) where 
glueVBal0 yw yx yy yz zu zw zx zy zz vuu True = glueBal (Branch yw yx yy yz zu) (Branch zw zx zy zz vuu)
glueVBal1 yw yx yy yz zu zw zx zy zz vuu True = mkBalBranch yw yx yz (glueVBal zu (Branch zw zx zy zz vuu))
glueVBal1 yw yx yy yz zu zw zx zy zz vuu False = glueVBal0 yw yx yy yz zu zw zx zy zz vuu otherwise
glueVBal2 yw yx yy yz zu zw zx zy zz vuu True = mkBalBranch zw zx (glueVBal (Branch yw yx yy yz zu) zz) vuu
glueVBal2 yw yx yy yz zu zw zx zy zz vuu False = glueVBal1 yw yx yy yz zu zw zx zy zz vuu (sIZE_RATIO * size_r < size_l)
size_l = sizeFM (Branch yw yx yy yz zu)
size_r = sizeFM (Branch zw zx zy zz vuu)

  
glueVBal4 fm1 EmptyFM = fm1
glueVBal4 wzw wzx = glueVBal3 wzw wzx

  
glueVBal5 EmptyFM fm2 = fm2
glueVBal5 wzz xuu = glueVBal4 wzz xuu

  mkBalBranch :: Ord a => a  ->  b  ->  FiniteMap a b  ->  FiniteMap a b  ->  FiniteMap a b
mkBalBranch key elt fm_L fm_R = mkBalBranch6 key elt fm_L fm_R

  
mkBalBranch6 key elt fm_L fm_R = 
mkBalBranch5 key elt fm_L fm_R (size_l + size_r < 2) where 
double_L fm_l (Branch key_r elt_r vxx (Branch key_rl elt_rl vxy fm_rll fm_rlr) fm_rr) = mkBranch 5 key_rl elt_rl (mkBranch 6 key elt fm_l fm_rll) (mkBranch 7 key_r elt_r fm_rlr fm_rr)
double_R (Branch key_l elt_l vwy fm_ll (Branch key_lr elt_lr vwz fm_lrl fm_lrr)) fm_r = mkBranch 10 key_lr elt_lr (mkBranch 11 key_l elt_l fm_ll fm_lrl) (mkBranch 12 key elt fm_lrr fm_r)
mkBalBranch0 fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr) = mkBalBranch02 fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr)
mkBalBranch00 fm_L fm_R vxz vyu vyv fm_rl fm_rr True = double_L fm_L fm_R
mkBalBranch01 fm_L fm_R vxz vyu vyv fm_rl fm_rr True = single_L fm_L fm_R
mkBalBranch01 fm_L fm_R vxz vyu vyv fm_rl fm_rr False = mkBalBranch00 fm_L fm_R vxz vyu vyv fm_rl fm_rr otherwise
mkBalBranch02 fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr) = mkBalBranch01 fm_L fm_R vxz vyu vyv fm_rl fm_rr (sizeFM fm_rl < 2 * sizeFM fm_rr)
mkBalBranch1 fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr) = mkBalBranch12 fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr)
mkBalBranch10 fm_L fm_R vxu vxv vxw fm_ll fm_lr True = double_R fm_L fm_R
mkBalBranch11 fm_L fm_R vxu vxv vxw fm_ll fm_lr True = single_R fm_L fm_R
mkBalBranch11 fm_L fm_R vxu vxv vxw fm_ll fm_lr False = mkBalBranch10 fm_L fm_R vxu vxv vxw fm_ll fm_lr otherwise
mkBalBranch12 fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr) = mkBalBranch11 fm_L fm_R vxu vxv vxw fm_ll fm_lr (sizeFM fm_lr < 2 * sizeFM fm_ll)
mkBalBranch2 key elt fm_L fm_R True = mkBranch 2 key elt fm_L fm_R
mkBalBranch3 key elt fm_L fm_R True = mkBalBranch1 fm_L fm_R fm_L
mkBalBranch3 key elt fm_L fm_R False = mkBalBranch2 key elt fm_L fm_R otherwise
mkBalBranch4 key elt fm_L fm_R True = mkBalBranch0 fm_L fm_R fm_R
mkBalBranch4 key elt fm_L fm_R False = mkBalBranch3 key elt fm_L fm_R (size_l > sIZE_RATIO * size_r)
mkBalBranch5 key elt fm_L fm_R True = mkBranch 1 key elt fm_L fm_R
mkBalBranch5 key elt fm_L fm_R False = mkBalBranch4 key elt fm_L fm_R (size_r > sIZE_RATIO * size_l)
single_L fm_l (Branch key_r elt_r vyw fm_rl fm_rr) = mkBranch 3 key_r elt_r (mkBranch 4 key elt fm_l fm_rl) fm_rr
single_R (Branch key_l elt_l vwx fm_ll fm_lr) fm_r = mkBranch 8 key_l elt_l fm_ll (mkBranch 9 key elt fm_lr fm_r)
size_l = sizeFM fm_L
size_r = sizeFM fm_R

  mkBranch :: Ord a => Int  ->  a  ->  b  ->  FiniteMap a b  ->  FiniteMap a b  ->  FiniteMap a b
mkBranch which key elt fm_l fm_r = 
let 
result = Branch key elt (unbox (1 + left_size + right_size)) fm_l fm_r
in result
 where 
balance_ok = True
left_ok = left_ok0 fm_l key fm_l
left_ok0 fm_l key EmptyFM = True
left_ok0 fm_l key (Branch left_key vw vx vy vz) = 
let 
biggest_left_key = fst (findMax fm_l)
in biggest_left_key < key
left_size = sizeFM fm_l
right_ok = right_ok0 fm_r key fm_r
right_ok0 fm_r key EmptyFM = True
right_ok0 fm_r key (Branch right_key wu wv ww wx) = 
let 
smallest_right_key = fst (findMin fm_r)
in key < smallest_right_key
right_size = sizeFM fm_r
unbox :: Int  ->  Int
unbox x = x

  mkVBalBranch :: Ord a => a  ->  b  ->  FiniteMap a b  ->  FiniteMap a b  ->  FiniteMap a b
mkVBalBranch key elt EmptyFM fm_r = mkVBalBranch5 key elt EmptyFM fm_r
mkVBalBranch key elt fm_l EmptyFM = mkVBalBranch4 key elt fm_l EmptyFM
mkVBalBranch key elt (Branch vuy vuz vvu vvv vvw) (Branch vvy vvz vwu vwv vww) = mkVBalBranch3 key elt (Branch vuy vuz vvu vvv vvw) (Branch vvy vvz vwu vwv vww)

  
mkVBalBranch3 key elt (Branch vuy vuz vvu vvv vvw) (Branch vvy vvz vwu vwv vww) = 
mkVBalBranch2 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww (sIZE_RATIO * size_l < size_r) where 
mkVBalBranch0 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww True = mkBranch 13 key elt (Branch vuy vuz vvu vvv vvw) (Branch vvy vvz vwu vwv vww)
mkVBalBranch1 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww True = mkBalBranch vuy vuz vvv (mkVBalBranch key elt vvw (Branch vvy vvz vwu vwv vww))
mkVBalBranch1 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww False = mkVBalBranch0 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww otherwise
mkVBalBranch2 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww True = mkBalBranch vvy vvz (mkVBalBranch key elt (Branch vuy vuz vvu vvv vvw) vwv) vww
mkVBalBranch2 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww False = mkVBalBranch1 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww (sIZE_RATIO * size_r < size_l)
size_l = sizeFM (Branch vuy vuz vvu vvv vvw)
size_r = sizeFM (Branch vvy vvz vwu vwv vww)

  
mkVBalBranch4 key elt fm_l EmptyFM = addToFM fm_l key elt
mkVBalBranch4 xuy xuz xvu xvv = mkVBalBranch3 xuy xuz xvu xvv

  
mkVBalBranch5 key elt EmptyFM fm_r = addToFM fm_r key elt
mkVBalBranch5 xvx xvy xvz xwu = mkVBalBranch4 xvx xvy xvz xwu

  sIZE_RATIO :: Int
sIZE_RATIO = 5

  sizeFM :: FiniteMap b a  ->  Int
sizeFM EmptyFM = 0
sizeFM (Branch xx xy size xz yu) = size

  unitFM :: a  ->  b  ->  FiniteMap a b
unitFM key elt = Branch key elt 1 emptyFM emptyFM


module Maybe where
  import qualified FiniteMap
import qualified Prelude


Let/Where Reductions:
The bindings of the following Let/Where expression
mkBalBranch5 key elt fm_L fm_R (size_l + size_r < 2)
where 
double_L fm_l (Branch key_r elt_r vxx (Branch key_rl elt_rl vxy fm_rll fm_rlr) fm_rr) = mkBranch 5 key_rl elt_rl (mkBranch 6 key elt fm_l fm_rll) (mkBranch 7 key_r elt_r fm_rlr fm_rr)
double_R (Branch key_l elt_l vwy fm_ll (Branch key_lr elt_lr vwz fm_lrl fm_lrr)) fm_r = mkBranch 10 key_lr elt_lr (mkBranch 11 key_l elt_l fm_ll fm_lrl) (mkBranch 12 key elt fm_lrr fm_r)
mkBalBranch0 fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr) = mkBalBranch02 fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr)
mkBalBranch00 fm_L fm_R vxz vyu vyv fm_rl fm_rr True = double_L fm_L fm_R
mkBalBranch01 fm_L fm_R vxz vyu vyv fm_rl fm_rr True = single_L fm_L fm_R
mkBalBranch01 fm_L fm_R vxz vyu vyv fm_rl fm_rr False = mkBalBranch00 fm_L fm_R vxz vyu vyv fm_rl fm_rr otherwise
mkBalBranch02 fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr) = mkBalBranch01 fm_L fm_R vxz vyu vyv fm_rl fm_rr (sizeFM fm_rl < 2 * sizeFM fm_rr)
mkBalBranch1 fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr) = mkBalBranch12 fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr)
mkBalBranch10 fm_L fm_R vxu vxv vxw fm_ll fm_lr True = double_R fm_L fm_R
mkBalBranch11 fm_L fm_R vxu vxv vxw fm_ll fm_lr True = single_R fm_L fm_R
mkBalBranch11 fm_L fm_R vxu vxv vxw fm_ll fm_lr False = mkBalBranch10 fm_L fm_R vxu vxv vxw fm_ll fm_lr otherwise
mkBalBranch12 fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr) = mkBalBranch11 fm_L fm_R vxu vxv vxw fm_ll fm_lr (sizeFM fm_lr < 2 * sizeFM fm_ll)
mkBalBranch2 key elt fm_L fm_R True = mkBranch 2 key elt fm_L fm_R
mkBalBranch3 key elt fm_L fm_R True = mkBalBranch1 fm_L fm_R fm_L
mkBalBranch3 key elt fm_L fm_R False = mkBalBranch2 key elt fm_L fm_R otherwise
mkBalBranch4 key elt fm_L fm_R True = mkBalBranch0 fm_L fm_R fm_R
mkBalBranch4 key elt fm_L fm_R False = mkBalBranch3 key elt fm_L fm_R (size_l > sIZE_RATIO * size_r)
mkBalBranch5 key elt fm_L fm_R True = mkBranch 1 key elt fm_L fm_R
mkBalBranch5 key elt fm_L fm_R False = mkBalBranch4 key elt fm_L fm_R (size_r > sIZE_RATIO * size_l)
single_L fm_l (Branch key_r elt_r vyw fm_rl fm_rr) = mkBranch 3 key_r elt_r (mkBranch 4 key elt fm_l fm_rl) fm_rr
single_R (Branch key_l elt_l vwx fm_ll fm_lr) fm_r = mkBranch 8 key_l elt_l fm_ll (mkBranch 9 key elt fm_lr fm_r)
size_l  = sizeFM fm_L
size_r  = sizeFM fm_R

are unpacked to the following functions on top level
mkBalBranch6Double_L yvz ywu ywv yww fm_l (Branch key_r elt_r vxx (Branch key_rl elt_rl vxy fm_rll fm_rlr) fm_rr) = mkBranch 5 key_rl elt_rl (mkBranch 6 yvz ywu fm_l fm_rll) (mkBranch 7 key_r elt_r fm_rlr fm_rr)

mkBalBranch6Size_l yvz ywu ywv yww = sizeFM ywv

mkBalBranch6Single_R yvz ywu ywv yww (Branch key_l elt_l vwx fm_ll fm_lr) fm_r = mkBranch 8 key_l elt_l fm_ll (mkBranch 9 yvz ywu fm_lr fm_r)

mkBalBranch6MkBalBranch0 yvz ywu ywv yww fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr) = mkBalBranch6MkBalBranch02 yvz ywu ywv yww fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr)

mkBalBranch6Single_L yvz ywu ywv yww fm_l (Branch key_r elt_r vyw fm_rl fm_rr) = mkBranch 3 key_r elt_r (mkBranch 4 yvz ywu fm_l fm_rl) fm_rr

mkBalBranch6Size_r yvz ywu ywv yww = sizeFM yww

mkBalBranch6MkBalBranch00 yvz ywu ywv yww fm_L fm_R vxz vyu vyv fm_rl fm_rr True = mkBalBranch6Double_L yvz ywu ywv yww fm_L fm_R

mkBalBranch6MkBalBranch4 yvz ywu ywv yww key elt fm_L fm_R True = mkBalBranch6MkBalBranch0 yvz ywu ywv yww fm_L fm_R fm_R
mkBalBranch6MkBalBranch4 yvz ywu ywv yww key elt fm_L fm_R False = mkBalBranch6MkBalBranch3 yvz ywu ywv yww key elt fm_L fm_R (mkBalBranch6Size_l yvz ywu ywv yww > sIZE_RATIO * mkBalBranch6Size_r yvz ywu ywv yww)

mkBalBranch6MkBalBranch12 yvz ywu ywv yww fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr) = mkBalBranch6MkBalBranch11 yvz ywu ywv yww fm_L fm_R vxu vxv vxw fm_ll fm_lr (sizeFM fm_lr < 2 * sizeFM fm_ll)

mkBalBranch6MkBalBranch01 yvz ywu ywv yww fm_L fm_R vxz vyu vyv fm_rl fm_rr True = mkBalBranch6Single_L yvz ywu ywv yww fm_L fm_R
mkBalBranch6MkBalBranch01 yvz ywu ywv yww fm_L fm_R vxz vyu vyv fm_rl fm_rr False = mkBalBranch6MkBalBranch00 yvz ywu ywv yww fm_L fm_R vxz vyu vyv fm_rl fm_rr otherwise

mkBalBranch6MkBalBranch11 yvz ywu ywv yww fm_L fm_R vxu vxv vxw fm_ll fm_lr True = mkBalBranch6Single_R yvz ywu ywv yww fm_L fm_R
mkBalBranch6MkBalBranch11 yvz ywu ywv yww fm_L fm_R vxu vxv vxw fm_ll fm_lr False = mkBalBranch6MkBalBranch10 yvz ywu ywv yww fm_L fm_R vxu vxv vxw fm_ll fm_lr otherwise

mkBalBranch6MkBalBranch10 yvz ywu ywv yww fm_L fm_R vxu vxv vxw fm_ll fm_lr True = mkBalBranch6Double_R yvz ywu ywv yww fm_L fm_R

mkBalBranch6MkBalBranch3 yvz ywu ywv yww key elt fm_L fm_R True = mkBalBranch6MkBalBranch1 yvz ywu ywv yww fm_L fm_R fm_L
mkBalBranch6MkBalBranch3 yvz ywu ywv yww key elt fm_L fm_R False = mkBalBranch6MkBalBranch2 yvz ywu ywv yww key elt fm_L fm_R otherwise

mkBalBranch6MkBalBranch02 yvz ywu ywv yww fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr) = mkBalBranch6MkBalBranch01 yvz ywu ywv yww fm_L fm_R vxz vyu vyv fm_rl fm_rr (sizeFM fm_rl < 2 * sizeFM fm_rr)

mkBalBranch6MkBalBranch5 yvz ywu ywv yww key elt fm_L fm_R True = mkBranch 1 key elt fm_L fm_R
mkBalBranch6MkBalBranch5 yvz ywu ywv yww key elt fm_L fm_R False = mkBalBranch6MkBalBranch4 yvz ywu ywv yww key elt fm_L fm_R (mkBalBranch6Size_r yvz ywu ywv yww > sIZE_RATIO * mkBalBranch6Size_l yvz ywu ywv yww)

mkBalBranch6MkBalBranch2 yvz ywu ywv yww key elt fm_L fm_R True = mkBranch 2 key elt fm_L fm_R

mkBalBranch6MkBalBranch1 yvz ywu ywv yww fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr) = mkBalBranch6MkBalBranch12 yvz ywu ywv yww fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr)

mkBalBranch6Double_R yvz ywu ywv yww (Branch key_l elt_l vwy fm_ll (Branch key_lr elt_lr vwz fm_lrl fm_lrr)) fm_r = mkBranch 10 key_lr elt_lr (mkBranch 11 key_l elt_l fm_ll fm_lrl) (mkBranch 12 yvz ywu fm_lrr fm_r)

The bindings of the following Let/Where expression
glueVBal2 yw yx yy yz zu zw zx zy zz vuu (sIZE_RATIO * size_l < size_r)
where 
glueVBal0 yw yx yy yz zu zw zx zy zz vuu True = glueBal (Branch yw yx yy yz zu) (Branch zw zx zy zz vuu)
glueVBal1 yw yx yy yz zu zw zx zy zz vuu True = mkBalBranch yw yx yz (glueVBal zu (Branch zw zx zy zz vuu))
glueVBal1 yw yx yy yz zu zw zx zy zz vuu False = glueVBal0 yw yx yy yz zu zw zx zy zz vuu otherwise
glueVBal2 yw yx yy yz zu zw zx zy zz vuu True = mkBalBranch zw zx (glueVBal (Branch yw yx yy yz zu) zz) vuu
glueVBal2 yw yx yy yz zu zw zx zy zz vuu False = glueVBal1 yw yx yy yz zu zw zx zy zz vuu (sIZE_RATIO * size_r < size_l)
size_l  = sizeFM (Branch yw yx yy yz zu)
size_r  = sizeFM (Branch zw zx zy zz vuu)

are unpacked to the following functions on top level
glueVBal3Size_l ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu = sizeFM (Branch ywx ywy ywz yxu yxv)

glueVBal3GlueVBal0 ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu yw yx yy yz zu zw zx zy zz vuu True = glueBal (Branch yw yx yy yz zu) (Branch zw zx zy zz vuu)

glueVBal3Size_r ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu = sizeFM (Branch yxw yxx yxy yxz yyu)

glueVBal3GlueVBal1 ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu yw yx yy yz zu zw zx zy zz vuu True = mkBalBranch yw yx yz (glueVBal zu (Branch zw zx zy zz vuu))
glueVBal3GlueVBal1 ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu yw yx yy yz zu zw zx zy zz vuu False = glueVBal3GlueVBal0 ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu yw yx yy yz zu zw zx zy zz vuu otherwise

glueVBal3GlueVBal2 ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu yw yx yy yz zu zw zx zy zz vuu True = mkBalBranch zw zx (glueVBal (Branch yw yx yy yz zu) zz) vuu
glueVBal3GlueVBal2 ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu yw yx yy yz zu zw zx zy zz vuu False = glueVBal3GlueVBal1 ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu yw yx yy yz zu zw zx zy zz vuu (sIZE_RATIO * glueVBal3Size_r ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu < glueVBal3Size_l ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu)

The bindings of the following Let/Where expression
let 
result  = Branch key elt (unbox (1 + left_size + right_size)) fm_l fm_r
in result
where 
balance_ok  = True
left_ok  = left_ok0 fm_l key fm_l
left_ok0 fm_l key EmptyFM = True
left_ok0 fm_l key (Branch left_key vw vx vy vz) = 
let 
biggest_left_key  = fst (findMax fm_l)
in biggest_left_key < key
left_size  = sizeFM fm_l
right_ok  = right_ok0 fm_r key fm_r
right_ok0 fm_r key EmptyFM = True
right_ok0 fm_r key (Branch right_key wu wv ww wx) = 
let 
smallest_right_key  = fst (findMin fm_r)
in key < smallest_right_key
right_size  = sizeFM fm_r
unbox x = x

are unpacked to the following functions on top level
mkBranchRight_ok yyv yyw yyx = mkBranchRight_ok0 yyv yyw yyx yyv yyw yyv

mkBranchLeft_size yyv yyw yyx = sizeFM yyx

mkBranchUnbox yyv yyw yyx x = x

mkBranchRight_size yyv yyw yyx = sizeFM yyv

mkBranchLeft_ok0 yyv yyw yyx fm_l key EmptyFM = True
mkBranchLeft_ok0 yyv yyw yyx fm_l key (Branch left_key vw vx vy vz) = mkBranchLeft_ok0Biggest_left_key fm_l < key

mkBranchLeft_ok yyv yyw yyx = mkBranchLeft_ok0 yyv yyw yyx yyx yyw yyx

mkBranchRight_ok0 yyv yyw yyx fm_r key EmptyFM = True
mkBranchRight_ok0 yyv yyw yyx fm_r key (Branch right_key wu wv ww wx) = key < mkBranchRight_ok0Smallest_right_key fm_r

mkBranchBalance_ok yyv yyw yyx = True

The bindings of the following Let/Where expression
let 
result  = Branch key elt (unbox (1 + left_size + right_size)) fm_l fm_r
in result

are unpacked to the following functions on top level
mkBranchResult yyy yyz yzu yzv = Branch yyy yyz (mkBranchUnbox yzu yyy yzv (1 + mkBranchLeft_size yzu yyy yzv + mkBranchRight_size yzu yyy yzv)) yzv yzu

The bindings of the following Let/Where expression
glueBal1 fm1 fm2 (sizeFM fm2 > sizeFM fm1)
where 
glueBal0 fm1 fm2 True = mkBalBranch mid_key1 mid_elt1 (deleteMax fm1) fm2
glueBal1 fm1 fm2 True = mkBalBranch mid_key2 mid_elt2 fm1 (deleteMin fm2)
glueBal1 fm1 fm2 False = glueBal0 fm1 fm2 otherwise
mid_elt1  = mid_elt10 vv2
mid_elt10 (vyx,mid_elt1) = mid_elt1
mid_elt2  = mid_elt20 vv3
mid_elt20 (vyy,mid_elt2) = mid_elt2
mid_key1  = mid_key10 vv2
mid_key10 (mid_key1,vyz) = mid_key1
mid_key2  = mid_key20 vv3
mid_key20 (mid_key2,vzu) = mid_key2
vv2  = findMax fm1
vv3  = findMin fm2

are unpacked to the following functions on top level
glueBal2Mid_elt20 yzw yzx (vyy,mid_elt2) = mid_elt2

glueBal2Mid_elt10 yzw yzx (vyx,mid_elt1) = mid_elt1

glueBal2GlueBal1 yzw yzx fm1 fm2 True = mkBalBranch (glueBal2Mid_key2 yzw yzx) (glueBal2Mid_elt2 yzw yzx) fm1 (deleteMin fm2)
glueBal2GlueBal1 yzw yzx fm1 fm2 False = glueBal2GlueBal0 yzw yzx fm1 fm2 otherwise

glueBal2GlueBal0 yzw yzx fm1 fm2 True = mkBalBranch (glueBal2Mid_key1 yzw yzx) (glueBal2Mid_elt1 yzw yzx) (deleteMax fm1) fm2

glueBal2Mid_elt2 yzw yzx = glueBal2Mid_elt20 yzw yzx (glueBal2Vv3 yzw yzx)

glueBal2Mid_key2 yzw yzx = glueBal2Mid_key20 yzw yzx (glueBal2Vv3 yzw yzx)

glueBal2Vv3 yzw yzx = findMin yzw

glueBal2Mid_elt1 yzw yzx = glueBal2Mid_elt10 yzw yzx (glueBal2Vv2 yzw yzx)

glueBal2Mid_key1 yzw yzx = glueBal2Mid_key10 yzw yzx (glueBal2Vv2 yzw yzx)

glueBal2Vv2 yzw yzx = findMax yzx

glueBal2Mid_key20 yzw yzx (mid_key2,vzu) = mid_key2

glueBal2Mid_key10 yzw yzx (mid_key1,vyz) = mid_key1

The bindings of the following Let/Where expression
mkVBalBranch2 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww (sIZE_RATIO * size_l < size_r)
where 
mkVBalBranch0 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww True = mkBranch 13 key elt (Branch vuy vuz vvu vvv vvw) (Branch vvy vvz vwu vwv vww)
mkVBalBranch1 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww True = mkBalBranch vuy vuz vvv (mkVBalBranch key elt vvw (Branch vvy vvz vwu vwv vww))
mkVBalBranch1 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww False = mkVBalBranch0 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww otherwise
mkVBalBranch2 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww True = mkBalBranch vvy vvz (mkVBalBranch key elt (Branch vuy vuz vvu vvv vvw) vwv) vww
mkVBalBranch2 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww False = mkVBalBranch1 key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww (sIZE_RATIO * size_r < size_l)
size_l  = sizeFM (Branch vuy vuz vvu vvv vvw)
size_r  = sizeFM (Branch vvy vvz vwu vwv vww)

are unpacked to the following functions on top level
mkVBalBranch3MkVBalBranch1 yzy yzz zuu zuv zuw zux zuy zuz zvu zvv key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww True = mkBalBranch vuy vuz vvv (mkVBalBranch key elt vvw (Branch vvy vvz vwu vwv vww))
mkVBalBranch3MkVBalBranch1 yzy yzz zuu zuv zuw zux zuy zuz zvu zvv key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww False = mkVBalBranch3MkVBalBranch0 yzy yzz zuu zuv zuw zux zuy zuz zvu zvv key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww otherwise

mkVBalBranch3Size_r yzy yzz zuu zuv zuw zux zuy zuz zvu zvv = sizeFM (Branch yzy yzz zuu zuv zuw)

mkVBalBranch3MkVBalBranch0 yzy yzz zuu zuv zuw zux zuy zuz zvu zvv key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww True = mkBranch 13 key elt (Branch vuy vuz vvu vvv vvw) (Branch vvy vvz vwu vwv vww)

mkVBalBranch3MkVBalBranch2 yzy yzz zuu zuv zuw zux zuy zuz zvu zvv key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww True = mkBalBranch vvy vvz (mkVBalBranch key elt (Branch vuy vuz vvu vvv vvw) vwv) vww
mkVBalBranch3MkVBalBranch2 yzy yzz zuu zuv zuw zux zuy zuz zvu zvv key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww False = mkVBalBranch3MkVBalBranch1 yzy yzz zuu zuv zuw zux zuy zuz zvu zvv key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww (sIZE_RATIO * mkVBalBranch3Size_r yzy yzz zuu zuv zuw zux zuy zuz zvu zvv < mkVBalBranch3Size_l yzy yzz zuu zuv zuw zux zuy zuz zvu zvv)

mkVBalBranch3Size_l yzy yzz zuu zuv zuw zux zuy zuz zvu zvv = sizeFM (Branch zux zuy zuz zvu zvv)

The bindings of the following Let/Where expression
let 
biggest_left_key  = fst (findMax fm_l)
in biggest_left_key < key

are unpacked to the following functions on top level
mkBranchLeft_ok0Biggest_left_key zvw = fst (findMax zvw)

The bindings of the following Let/Where expression
let 
smallest_right_key  = fst (findMin fm_r)
in key < smallest_right_key

are unpacked to the following functions on top level
mkBranchRight_ok0Smallest_right_key zvx = fst (findMin zvx)

The bindings of the following Let/Where expression
reduce1 x y (y == 0)
where 
d  = gcd x y
reduce0 x y True = x `quot` d :% (y `quot` d)
reduce1 x y True = error []
reduce1 x y False = reduce0 x y otherwise

are unpacked to the following functions on top level
reduce2Reduce1 zvy zvz x y True = error []
reduce2Reduce1 zvy zvz x y False = reduce2Reduce0 zvy zvz x y otherwise

reduce2Reduce0 zvy zvz x y True = x `quot` reduce2D zvy zvz :% (y `quot` reduce2D zvy zvz)

reduce2D zvy zvz = gcd zvy zvz

The bindings of the following Let/Where expression
gcd' (abs x) (abs y)
where 
gcd' x xzv = gcd'2 x xzv
gcd' x y = gcd'0 x y
gcd'0 x y = gcd' y (x `rem` y)
gcd'1 True x xzv = x
gcd'1 xzw xzx xzy = gcd'0 xzx xzy
gcd'2 x xzv = gcd'1 (xzv == 0) x xzv
gcd'2 xzz yuu = gcd'0 xzz yuu

are unpacked to the following functions on top level
gcd0Gcd'0 x y = gcd0Gcd' y (x `rem` y)

gcd0Gcd' x xzv = gcd0Gcd'2 x xzv
gcd0Gcd' x y = gcd0Gcd'0 x y

gcd0Gcd'2 x xzv = gcd0Gcd'1 (xzv == 0) x xzv
gcd0Gcd'2 xzz yuu = gcd0Gcd'0 xzz yuu

gcd0Gcd'1 True x xzv = x
gcd0Gcd'1 xzw xzx xzy = gcd0Gcd'0 xzx xzy



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed

mainModule FiniteMap
  ((filterFM :: Ord a => (a  ->  b  ->  Bool)  ->  FiniteMap a b  ->  FiniteMap a b) :: Ord a => (a  ->  b  ->  Bool)  ->  FiniteMap a b  ->  FiniteMap a b)

module FiniteMap where
  import qualified Maybe
import qualified Prelude
  data FiniteMap b a = EmptyFM  | Branch b a Int (FiniteMap b a) (FiniteMap b a) 
  instance (Eq a, Eq b) => Eq (FiniteMap a b) where 
   
(==) fm_1 fm_2 = sizeFM fm_1 == sizeFM fm_2 && fmToList fm_1 == fmToList fm_2

  addToFM :: Ord b => FiniteMap b a  ->  b  ->  a  ->  FiniteMap b a
addToFM fm key elt = addToFM_C addToFM0 fm key elt

  
addToFM0 old new = new

  addToFM_C :: Ord a => (b  ->  b  ->  b)  ->  FiniteMap a b  ->  a  ->  b  ->  FiniteMap a b
addToFM_C combiner EmptyFM key elt = addToFM_C4 combiner EmptyFM key elt
addToFM_C combiner (Branch key elt size fm_l fm_r) new_key new_elt = addToFM_C3 combiner (Branch key elt size fm_l fm_r) new_key new_elt

  
addToFM_C0 combiner key elt size fm_l fm_r new_key new_elt True = Branch new_key (combiner elt new_elt) size fm_l fm_r

  
addToFM_C1 combiner key elt size fm_l fm_r new_key new_elt True = mkBalBranch key elt fm_l (addToFM_C combiner fm_r new_key new_elt)
addToFM_C1 combiner key elt size fm_l fm_r new_key new_elt False = addToFM_C0 combiner key elt size fm_l fm_r new_key new_elt otherwise

  
addToFM_C2 combiner key elt size fm_l fm_r new_key new_elt True = mkBalBranch key elt (addToFM_C combiner fm_l new_key new_elt) fm_r
addToFM_C2 combiner key elt size fm_l fm_r new_key new_elt False = addToFM_C1 combiner key elt size fm_l fm_r new_key new_elt (new_key > key)

  
addToFM_C3 combiner (Branch key elt size fm_l fm_r) new_key new_elt = addToFM_C2 combiner key elt size fm_l fm_r new_key new_elt (new_key < key)

  
addToFM_C4 combiner EmptyFM key elt = unitFM key elt
addToFM_C4 xxz xyu xyv xyw = addToFM_C3 xxz xyu xyv xyw

  deleteMax :: Ord b => FiniteMap b a  ->  FiniteMap b a
deleteMax (Branch key elt vuv fm_l EmptyFM) = fm_l
deleteMax (Branch key elt vuw fm_l fm_r) = mkBalBranch key elt fm_l (deleteMax fm_r)

  deleteMin :: Ord b => FiniteMap b a  ->  FiniteMap b a
deleteMin (Branch key elt vzz EmptyFM fm_r) = fm_r
deleteMin (Branch key elt wuu fm_l fm_r) = mkBalBranch key elt (deleteMin fm_l) fm_r

  emptyFM :: FiniteMap b a
emptyFM = EmptyFM

  filterFM :: Ord a => (a  ->  b  ->  Bool)  ->  FiniteMap a b  ->  FiniteMap a b
filterFM p EmptyFM = filterFM3 p EmptyFM
filterFM p (Branch key elt wuv fm_l fm_r) = filterFM2 p (Branch key elt wuv fm_l fm_r)

  
filterFM0 p key elt wuv fm_l fm_r True = glueVBal (filterFM p fm_l) (filterFM p fm_r)

  
filterFM1 p key elt wuv fm_l fm_r True = mkVBalBranch key elt (filterFM p fm_l) (filterFM p fm_r)
filterFM1 p key elt wuv fm_l fm_r False = filterFM0 p key elt wuv fm_l fm_r otherwise

  
filterFM2 p (Branch key elt wuv fm_l fm_r) = filterFM1 p key elt wuv fm_l fm_r (p key elt)

  
filterFM3 p EmptyFM = emptyFM
filterFM3 xyz xzu = filterFM2 xyz xzu

  findMax :: FiniteMap a b  ->  (a,b)
findMax (Branch key elt vzv vzw EmptyFM) = (key,elt)
findMax (Branch key elt vzx vzy fm_r) = findMax fm_r

  findMin :: FiniteMap a b  ->  (a,b)
findMin (Branch key elt wz EmptyFM xu) = (key,elt)
findMin (Branch key elt xv fm_l xw) = findMin fm_l

  fmToList :: FiniteMap a b  ->  [(a,b)]
fmToList fm = foldFM fmToList0 [] fm

  
fmToList0 key elt rest = (key,elt) : rest

  foldFM :: (a  ->  c  ->  b  ->  b)  ->  b  ->  FiniteMap a c  ->  b
foldFM k z EmptyFM = z
foldFM k z (Branch key elt wy fm_l fm_r) = foldFM k (k key elt (foldFM k z fm_r)) fm_l

  glueBal :: Ord a => FiniteMap a b  ->  FiniteMap a b  ->  FiniteMap a b
glueBal EmptyFM fm2 = glueBal4 EmptyFM fm2
glueBal fm1 EmptyFM = glueBal3 fm1 EmptyFM
glueBal fm1 fm2 = glueBal2 fm1 fm2

  
glueBal2 fm1 fm2 = glueBal2GlueBal1 fm2 fm1 fm1 fm2 (sizeFM fm2 > sizeFM fm1)

  
glueBal2GlueBal0 yzw yzx fm1 fm2 True = mkBalBranch (glueBal2Mid_key1 yzw yzx) (glueBal2Mid_elt1 yzw yzx) (deleteMax fm1) fm2

  
glueBal2GlueBal1 yzw yzx fm1 fm2 True = mkBalBranch (glueBal2Mid_key2 yzw yzx) (glueBal2Mid_elt2 yzw yzx) fm1 (deleteMin fm2)
glueBal2GlueBal1 yzw yzx fm1 fm2 False = glueBal2GlueBal0 yzw yzx fm1 fm2 otherwise

  
glueBal2Mid_elt1 yzw yzx = glueBal2Mid_elt10 yzw yzx (glueBal2Vv2 yzw yzx)

  
glueBal2Mid_elt10 yzw yzx (vyx,mid_elt1) = mid_elt1

  
glueBal2Mid_elt2 yzw yzx = glueBal2Mid_elt20 yzw yzx (glueBal2Vv3 yzw yzx)

  
glueBal2Mid_elt20 yzw yzx (vyy,mid_elt2) = mid_elt2

  
glueBal2Mid_key1 yzw yzx = glueBal2Mid_key10 yzw yzx (glueBal2Vv2 yzw yzx)

  
glueBal2Mid_key10 yzw yzx (mid_key1,vyz) = mid_key1

  
glueBal2Mid_key2 yzw yzx = glueBal2Mid_key20 yzw yzx (glueBal2Vv3 yzw yzx)

  
glueBal2Mid_key20 yzw yzx (mid_key2,vzu) = mid_key2

  
glueBal2Vv2 yzw yzx = findMax yzx

  
glueBal2Vv3 yzw yzx = findMin yzw

  
glueBal3 fm1 EmptyFM = fm1
glueBal3 xwy xwz = glueBal2 xwy xwz

  
glueBal4 EmptyFM fm2 = fm2
glueBal4 xxv xxw = glueBal3 xxv xxw

  glueVBal :: Ord a => FiniteMap a b  ->  FiniteMap a b  ->  FiniteMap a b
glueVBal EmptyFM fm2 = glueVBal5 EmptyFM fm2
glueVBal fm1 EmptyFM = glueVBal4 fm1 EmptyFM
glueVBal (Branch yw yx yy yz zu) (Branch zw zx zy zz vuu) = glueVBal3 (Branch yw yx yy yz zu) (Branch zw zx zy zz vuu)

  
glueVBal3 (Branch yw yx yy yz zu) (Branch zw zx zy zz vuu) = glueVBal3GlueVBal2 yw yx yy yz zu zw zx zy zz vuu yw yx yy yz zu zw zx zy zz vuu (sIZE_RATIO * glueVBal3Size_l yw yx yy yz zu zw zx zy zz vuu < glueVBal3Size_r yw yx yy yz zu zw zx zy zz vuu)

  
glueVBal3GlueVBal0 ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu yw yx yy yz zu zw zx zy zz vuu True = glueBal (Branch yw yx yy yz zu) (Branch zw zx zy zz vuu)

  
glueVBal3GlueVBal1 ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu yw yx yy yz zu zw zx zy zz vuu True = mkBalBranch yw yx yz (glueVBal zu (Branch zw zx zy zz vuu))
glueVBal3GlueVBal1 ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu yw yx yy yz zu zw zx zy zz vuu False = glueVBal3GlueVBal0 ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu yw yx yy yz zu zw zx zy zz vuu otherwise

  
glueVBal3GlueVBal2 ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu yw yx yy yz zu zw zx zy zz vuu True = mkBalBranch zw zx (glueVBal (Branch yw yx yy yz zu) zz) vuu
glueVBal3GlueVBal2 ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu yw yx yy yz zu zw zx zy zz vuu False = glueVBal3GlueVBal1 ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu yw yx yy yz zu zw zx zy zz vuu (sIZE_RATIO * glueVBal3Size_r ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu < glueVBal3Size_l ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu)

  
glueVBal3Size_l ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu = sizeFM (Branch ywx ywy ywz yxu yxv)

  
glueVBal3Size_r ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu = sizeFM (Branch yxw yxx yxy yxz yyu)

  
glueVBal4 fm1 EmptyFM = fm1
glueVBal4 wzw wzx = glueVBal3 wzw wzx

  
glueVBal5 EmptyFM fm2 = fm2
glueVBal5 wzz xuu = glueVBal4 wzz xuu

  mkBalBranch :: Ord a => a  ->  b  ->  FiniteMap a b  ->  FiniteMap a b  ->  FiniteMap a b
mkBalBranch key elt fm_L fm_R = mkBalBranch6 key elt fm_L fm_R

  
mkBalBranch6 key elt fm_L fm_R = mkBalBranch6MkBalBranch5 key elt fm_L fm_R key elt fm_L fm_R (mkBalBranch6Size_l key elt fm_L fm_R + mkBalBranch6Size_r key elt fm_L fm_R < 2)

  
mkBalBranch6Double_L yvz ywu ywv yww fm_l (Branch key_r elt_r vxx (Branch key_rl elt_rl vxy fm_rll fm_rlr) fm_rr) = mkBranch 5 key_rl elt_rl (mkBranch 6 yvz ywu fm_l fm_rll) (mkBranch 7 key_r elt_r fm_rlr fm_rr)

  
mkBalBranch6Double_R yvz ywu ywv yww (Branch key_l elt_l vwy fm_ll (Branch key_lr elt_lr vwz fm_lrl fm_lrr)) fm_r = mkBranch 10 key_lr elt_lr (mkBranch 11 key_l elt_l fm_ll fm_lrl) (mkBranch 12 yvz ywu fm_lrr fm_r)

  
mkBalBranch6MkBalBranch0 yvz ywu ywv yww fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr) = mkBalBranch6MkBalBranch02 yvz ywu ywv yww fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr)

  
mkBalBranch6MkBalBranch00 yvz ywu ywv yww fm_L fm_R vxz vyu vyv fm_rl fm_rr True = mkBalBranch6Double_L yvz ywu ywv yww fm_L fm_R

  
mkBalBranch6MkBalBranch01 yvz ywu ywv yww fm_L fm_R vxz vyu vyv fm_rl fm_rr True = mkBalBranch6Single_L yvz ywu ywv yww fm_L fm_R
mkBalBranch6MkBalBranch01 yvz ywu ywv yww fm_L fm_R vxz vyu vyv fm_rl fm_rr False = mkBalBranch6MkBalBranch00 yvz ywu ywv yww fm_L fm_R vxz vyu vyv fm_rl fm_rr otherwise

  
mkBalBranch6MkBalBranch02 yvz ywu ywv yww fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr) = mkBalBranch6MkBalBranch01 yvz ywu ywv yww fm_L fm_R vxz vyu vyv fm_rl fm_rr (sizeFM fm_rl < 2 * sizeFM fm_rr)

  
mkBalBranch6MkBalBranch1 yvz ywu ywv yww fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr) = mkBalBranch6MkBalBranch12 yvz ywu ywv yww fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr)

  
mkBalBranch6MkBalBranch10 yvz ywu ywv yww fm_L fm_R vxu vxv vxw fm_ll fm_lr True = mkBalBranch6Double_R yvz ywu ywv yww fm_L fm_R

  
mkBalBranch6MkBalBranch11 yvz ywu ywv yww fm_L fm_R vxu vxv vxw fm_ll fm_lr True = mkBalBranch6Single_R yvz ywu ywv yww fm_L fm_R
mkBalBranch6MkBalBranch11 yvz ywu ywv yww fm_L fm_R vxu vxv vxw fm_ll fm_lr False = mkBalBranch6MkBalBranch10 yvz ywu ywv yww fm_L fm_R vxu vxv vxw fm_ll fm_lr otherwise

  
mkBalBranch6MkBalBranch12 yvz ywu ywv yww fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr) = mkBalBranch6MkBalBranch11 yvz ywu ywv yww fm_L fm_R vxu vxv vxw fm_ll fm_lr (sizeFM fm_lr < 2 * sizeFM fm_ll)

  
mkBalBranch6MkBalBranch2 yvz ywu ywv yww key elt fm_L fm_R True = mkBranch 2 key elt fm_L fm_R

  
mkBalBranch6MkBalBranch3 yvz ywu ywv yww key elt fm_L fm_R True = mkBalBranch6MkBalBranch1 yvz ywu ywv yww fm_L fm_R fm_L
mkBalBranch6MkBalBranch3 yvz ywu ywv yww key elt fm_L fm_R False = mkBalBranch6MkBalBranch2 yvz ywu ywv yww key elt fm_L fm_R otherwise

  
mkBalBranch6MkBalBranch4 yvz ywu ywv yww key elt fm_L fm_R True = mkBalBranch6MkBalBranch0 yvz ywu ywv yww fm_L fm_R fm_R
mkBalBranch6MkBalBranch4 yvz ywu ywv yww key elt fm_L fm_R False = mkBalBranch6MkBalBranch3 yvz ywu ywv yww key elt fm_L fm_R (mkBalBranch6Size_l yvz ywu ywv yww > sIZE_RATIO * mkBalBranch6Size_r yvz ywu ywv yww)

  
mkBalBranch6MkBalBranch5 yvz ywu ywv yww key elt fm_L fm_R True = mkBranch 1 key elt fm_L fm_R
mkBalBranch6MkBalBranch5 yvz ywu ywv yww key elt fm_L fm_R False = mkBalBranch6MkBalBranch4 yvz ywu ywv yww key elt fm_L fm_R (mkBalBranch6Size_r yvz ywu ywv yww > sIZE_RATIO * mkBalBranch6Size_l yvz ywu ywv yww)

  
mkBalBranch6Single_L yvz ywu ywv yww fm_l (Branch key_r elt_r vyw fm_rl fm_rr) = mkBranch 3 key_r elt_r (mkBranch 4 yvz ywu fm_l fm_rl) fm_rr

  
mkBalBranch6Single_R yvz ywu ywv yww (Branch key_l elt_l vwx fm_ll fm_lr) fm_r = mkBranch 8 key_l elt_l fm_ll (mkBranch 9 yvz ywu fm_lr fm_r)

  
mkBalBranch6Size_l yvz ywu ywv yww = sizeFM ywv

  
mkBalBranch6Size_r yvz ywu ywv yww = sizeFM yww

  mkBranch :: Ord b => Int  ->  b  ->  a  ->  FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
mkBranch which key elt fm_l fm_r = mkBranchResult key elt fm_r fm_l

  
mkBranchBalance_ok yyv yyw yyx = True

  
mkBranchLeft_ok yyv yyw yyx = mkBranchLeft_ok0 yyv yyw yyx yyx yyw yyx

  
mkBranchLeft_ok0 yyv yyw yyx fm_l key EmptyFM = True
mkBranchLeft_ok0 yyv yyw yyx fm_l key (Branch left_key vw vx vy vz) = mkBranchLeft_ok0Biggest_left_key fm_l < key

  
mkBranchLeft_ok0Biggest_left_key zvw = fst (findMax zvw)

  
mkBranchLeft_size yyv yyw yyx = sizeFM yyx

  
mkBranchResult yyy yyz yzu yzv = Branch yyy yyz (mkBranchUnbox yzu yyy yzv (1 + mkBranchLeft_size yzu yyy yzv + mkBranchRight_size yzu yyy yzv)) yzv yzu

  
mkBranchRight_ok yyv yyw yyx = mkBranchRight_ok0 yyv yyw yyx yyv yyw yyv

  
mkBranchRight_ok0 yyv yyw yyx fm_r key EmptyFM = True
mkBranchRight_ok0 yyv yyw yyx fm_r key (Branch right_key wu wv ww wx) = key < mkBranchRight_ok0Smallest_right_key fm_r

  
mkBranchRight_ok0Smallest_right_key zvx = fst (findMin zvx)

  
mkBranchRight_size yyv yyw yyx = sizeFM yyv

  mkBranchUnbox :: Ord a =>  ->  (FiniteMap a b) ( ->  a ( ->  (FiniteMap a b) (Int  ->  Int)))
mkBranchUnbox yyv yyw yyx x = x

  mkVBalBranch :: Ord a => a  ->  b  ->  FiniteMap a b  ->  FiniteMap a b  ->  FiniteMap a b
mkVBalBranch key elt EmptyFM fm_r = mkVBalBranch5 key elt EmptyFM fm_r
mkVBalBranch key elt fm_l EmptyFM = mkVBalBranch4 key elt fm_l EmptyFM
mkVBalBranch key elt (Branch vuy vuz vvu vvv vvw) (Branch vvy vvz vwu vwv vww) = mkVBalBranch3 key elt (Branch vuy vuz vvu vvv vvw) (Branch vvy vvz vwu vwv vww)

  
mkVBalBranch3 key elt (Branch vuy vuz vvu vvv vvw) (Branch vvy vvz vwu vwv vww) = mkVBalBranch3MkVBalBranch2 vvy vvz vwu vwv vww vuy vuz vvu vvv vvw key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww (sIZE_RATIO * mkVBalBranch3Size_l vvy vvz vwu vwv vww vuy vuz vvu vvv vvw < mkVBalBranch3Size_r vvy vvz vwu vwv vww vuy vuz vvu vvv vvw)

  
mkVBalBranch3MkVBalBranch0 yzy yzz zuu zuv zuw zux zuy zuz zvu zvv key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww True = mkBranch 13 key elt (Branch vuy vuz vvu vvv vvw) (Branch vvy vvz vwu vwv vww)

  
mkVBalBranch3MkVBalBranch1 yzy yzz zuu zuv zuw zux zuy zuz zvu zvv key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww True = mkBalBranch vuy vuz vvv (mkVBalBranch key elt vvw (Branch vvy vvz vwu vwv vww))
mkVBalBranch3MkVBalBranch1 yzy yzz zuu zuv zuw zux zuy zuz zvu zvv key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww False = mkVBalBranch3MkVBalBranch0 yzy yzz zuu zuv zuw zux zuy zuz zvu zvv key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww otherwise

  
mkVBalBranch3MkVBalBranch2 yzy yzz zuu zuv zuw zux zuy zuz zvu zvv key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww True = mkBalBranch vvy vvz (mkVBalBranch key elt (Branch vuy vuz vvu vvv vvw) vwv) vww
mkVBalBranch3MkVBalBranch2 yzy yzz zuu zuv zuw zux zuy zuz zvu zvv key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww False = mkVBalBranch3MkVBalBranch1 yzy yzz zuu zuv zuw zux zuy zuz zvu zvv key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww (sIZE_RATIO * mkVBalBranch3Size_r yzy yzz zuu zuv zuw zux zuy zuz zvu zvv < mkVBalBranch3Size_l yzy yzz zuu zuv zuw zux zuy zuz zvu zvv)

  
mkVBalBranch3Size_l yzy yzz zuu zuv zuw zux zuy zuz zvu zvv = sizeFM (Branch zux zuy zuz zvu zvv)

  
mkVBalBranch3Size_r yzy yzz zuu zuv zuw zux zuy zuz zvu zvv = sizeFM (Branch yzy yzz zuu zuv zuw)

  
mkVBalBranch4 key elt fm_l EmptyFM = addToFM fm_l key elt
mkVBalBranch4 xuy xuz xvu xvv = mkVBalBranch3 xuy xuz xvu xvv

  
mkVBalBranch5 key elt EmptyFM fm_r = addToFM fm_r key elt
mkVBalBranch5 xvx xvy xvz xwu = mkVBalBranch4 xvx xvy xvz xwu

  sIZE_RATIO :: Int
sIZE_RATIO = 5

  sizeFM :: FiniteMap b a  ->  Int
sizeFM EmptyFM = 0
sizeFM (Branch xx xy size xz yu) = size

  unitFM :: a  ->  b  ->  FiniteMap a b
unitFM key elt = Branch key elt 1 emptyFM emptyFM


module Maybe where
  import qualified FiniteMap
import qualified Prelude


Num Reduction: All numbers are transformed to thier corresponding representation with Pos, Neg, Succ and Zero.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow

mainModule FiniteMap
  (filterFM :: Ord a => (a  ->  b  ->  Bool)  ->  FiniteMap a b  ->  FiniteMap a b)

module FiniteMap where
  import qualified Maybe
import qualified Prelude
  data FiniteMap a b = EmptyFM  | Branch a b Int (FiniteMap a b) (FiniteMap a b) 
  instance (Eq a, Eq b) => Eq (FiniteMap b a) where 
   
(==) fm_1 fm_2 = sizeFM fm_1 == sizeFM fm_2 && fmToList fm_1 == fmToList fm_2

  addToFM :: Ord a => FiniteMap a b  ->  a  ->  b  ->  FiniteMap a b
addToFM fm key elt = addToFM_C addToFM0 fm key elt

  
addToFM0 old new = new

  addToFM_C :: Ord b => (a  ->  a  ->  a)  ->  FiniteMap b a  ->  b  ->  a  ->  FiniteMap b a
addToFM_C combiner EmptyFM key elt = addToFM_C4 combiner EmptyFM key elt
addToFM_C combiner (Branch key elt size fm_l fm_r) new_key new_elt = addToFM_C3 combiner (Branch key elt size fm_l fm_r) new_key new_elt

  
addToFM_C0 combiner key elt size fm_l fm_r new_key new_elt True = Branch new_key (combiner elt new_elt) size fm_l fm_r

  
addToFM_C1 combiner key elt size fm_l fm_r new_key new_elt True = mkBalBranch key elt fm_l (addToFM_C combiner fm_r new_key new_elt)
addToFM_C1 combiner key elt size fm_l fm_r new_key new_elt False = addToFM_C0 combiner key elt size fm_l fm_r new_key new_elt otherwise

  
addToFM_C2 combiner key elt size fm_l fm_r new_key new_elt True = mkBalBranch key elt (addToFM_C combiner fm_l new_key new_elt) fm_r
addToFM_C2 combiner key elt size fm_l fm_r new_key new_elt False = addToFM_C1 combiner key elt size fm_l fm_r new_key new_elt (new_key > key)

  
addToFM_C3 combiner (Branch key elt size fm_l fm_r) new_key new_elt = addToFM_C2 combiner key elt size fm_l fm_r new_key new_elt (new_key < key)

  
addToFM_C4 combiner EmptyFM key elt = unitFM key elt
addToFM_C4 xxz xyu xyv xyw = addToFM_C3 xxz xyu xyv xyw

  deleteMax :: Ord b => FiniteMap b a  ->  FiniteMap b a
deleteMax (Branch key elt vuv fm_l EmptyFM) = fm_l
deleteMax (Branch key elt vuw fm_l fm_r) = mkBalBranch key elt fm_l (deleteMax fm_r)

  deleteMin :: Ord b => FiniteMap b a  ->  FiniteMap b a
deleteMin (Branch key elt vzz EmptyFM fm_r) = fm_r
deleteMin (Branch key elt wuu fm_l fm_r) = mkBalBranch key elt (deleteMin fm_l) fm_r

  emptyFM :: FiniteMap b a
emptyFM = EmptyFM

  filterFM :: Ord a => (a  ->  b  ->  Bool)  ->  FiniteMap a b  ->  FiniteMap a b
filterFM p EmptyFM = filterFM3 p EmptyFM
filterFM p (Branch key elt wuv fm_l fm_r) = filterFM2 p (Branch key elt wuv fm_l fm_r)

  
filterFM0 p key elt wuv fm_l fm_r True = glueVBal (filterFM p fm_l) (filterFM p fm_r)

  
filterFM1 p key elt wuv fm_l fm_r True = mkVBalBranch key elt (filterFM p fm_l) (filterFM p fm_r)
filterFM1 p key elt wuv fm_l fm_r False = filterFM0 p key elt wuv fm_l fm_r otherwise

  
filterFM2 p (Branch key elt wuv fm_l fm_r) = filterFM1 p key elt wuv fm_l fm_r (p key elt)

  
filterFM3 p EmptyFM = emptyFM
filterFM3 xyz xzu = filterFM2 xyz xzu

  findMax :: FiniteMap b a  ->  (b,a)
findMax (Branch key elt vzv vzw EmptyFM) = (key,elt)
findMax (Branch key elt vzx vzy fm_r) = findMax fm_r

  findMin :: FiniteMap a b  ->  (a,b)
findMin (Branch key elt wz EmptyFM xu) = (key,elt)
findMin (Branch key elt xv fm_l xw) = findMin fm_l

  fmToList :: FiniteMap b a  ->  [(b,a)]
fmToList fm = foldFM fmToList0 [] fm

  
fmToList0 key elt rest = (key,elt) : rest

  foldFM :: (b  ->  c  ->  a  ->  a)  ->  a  ->  FiniteMap b c  ->  a
foldFM k z EmptyFM = z
foldFM k z (Branch key elt wy fm_l fm_r) = foldFM k (k key elt (foldFM k z fm_r)) fm_l

  glueBal :: Ord a => FiniteMap a b  ->  FiniteMap a b  ->  FiniteMap a b
glueBal EmptyFM fm2 = glueBal4 EmptyFM fm2
glueBal fm1 EmptyFM = glueBal3 fm1 EmptyFM
glueBal fm1 fm2 = glueBal2 fm1 fm2

  
glueBal2 fm1 fm2 = glueBal2GlueBal1 fm2 fm1 fm1 fm2 (sizeFM fm2 > sizeFM fm1)

  
glueBal2GlueBal0 yzw yzx fm1 fm2 True = mkBalBranch (glueBal2Mid_key1 yzw yzx) (glueBal2Mid_elt1 yzw yzx) (deleteMax fm1) fm2

  
glueBal2GlueBal1 yzw yzx fm1 fm2 True = mkBalBranch (glueBal2Mid_key2 yzw yzx) (glueBal2Mid_elt2 yzw yzx) fm1 (deleteMin fm2)
glueBal2GlueBal1 yzw yzx fm1 fm2 False = glueBal2GlueBal0 yzw yzx fm1 fm2 otherwise

  
glueBal2Mid_elt1 yzw yzx = glueBal2Mid_elt10 yzw yzx (glueBal2Vv2 yzw yzx)

  
glueBal2Mid_elt10 yzw yzx (vyx,mid_elt1) = mid_elt1

  
glueBal2Mid_elt2 yzw yzx = glueBal2Mid_elt20 yzw yzx (glueBal2Vv3 yzw yzx)

  
glueBal2Mid_elt20 yzw yzx (vyy,mid_elt2) = mid_elt2

  
glueBal2Mid_key1 yzw yzx = glueBal2Mid_key10 yzw yzx (glueBal2Vv2 yzw yzx)

  
glueBal2Mid_key10 yzw yzx (mid_key1,vyz) = mid_key1

  
glueBal2Mid_key2 yzw yzx = glueBal2Mid_key20 yzw yzx (glueBal2Vv3 yzw yzx)

  
glueBal2Mid_key20 yzw yzx (mid_key2,vzu) = mid_key2

  
glueBal2Vv2 yzw yzx = findMax yzx

  
glueBal2Vv3 yzw yzx = findMin yzw

  
glueBal3 fm1 EmptyFM = fm1
glueBal3 xwy xwz = glueBal2 xwy xwz

  
glueBal4 EmptyFM fm2 = fm2
glueBal4 xxv xxw = glueBal3 xxv xxw

  glueVBal :: Ord b => FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
glueVBal EmptyFM fm2 = glueVBal5 EmptyFM fm2
glueVBal fm1 EmptyFM = glueVBal4 fm1 EmptyFM
glueVBal (Branch yw yx yy yz zu) (Branch zw zx zy zz vuu) = glueVBal3 (Branch yw yx yy yz zu) (Branch zw zx zy zz vuu)

  
glueVBal3 (Branch yw yx yy yz zu) (Branch zw zx zy zz vuu) = glueVBal3GlueVBal2 yw yx yy yz zu zw zx zy zz vuu yw yx yy yz zu zw zx zy zz vuu (sIZE_RATIO * glueVBal3Size_l yw yx yy yz zu zw zx zy zz vuu < glueVBal3Size_r yw yx yy yz zu zw zx zy zz vuu)

  
glueVBal3GlueVBal0 ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu yw yx yy yz zu zw zx zy zz vuu True = glueBal (Branch yw yx yy yz zu) (Branch zw zx zy zz vuu)

  
glueVBal3GlueVBal1 ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu yw yx yy yz zu zw zx zy zz vuu True = mkBalBranch yw yx yz (glueVBal zu (Branch zw zx zy zz vuu))
glueVBal3GlueVBal1 ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu yw yx yy yz zu zw zx zy zz vuu False = glueVBal3GlueVBal0 ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu yw yx yy yz zu zw zx zy zz vuu otherwise

  
glueVBal3GlueVBal2 ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu yw yx yy yz zu zw zx zy zz vuu True = mkBalBranch zw zx (glueVBal (Branch yw yx yy yz zu) zz) vuu
glueVBal3GlueVBal2 ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu yw yx yy yz zu zw zx zy zz vuu False = glueVBal3GlueVBal1 ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu yw yx yy yz zu zw zx zy zz vuu (sIZE_RATIO * glueVBal3Size_r ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu < glueVBal3Size_l ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu)

  
glueVBal3Size_l ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu = sizeFM (Branch ywx ywy ywz yxu yxv)

  
glueVBal3Size_r ywx ywy ywz yxu yxv yxw yxx yxy yxz yyu = sizeFM (Branch yxw yxx yxy yxz yyu)

  
glueVBal4 fm1 EmptyFM = fm1
glueVBal4 wzw wzx = glueVBal3 wzw wzx

  
glueVBal5 EmptyFM fm2 = fm2
glueVBal5 wzz xuu = glueVBal4 wzz xuu

  mkBalBranch :: Ord b => b  ->  a  ->  FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
mkBalBranch key elt fm_L fm_R = mkBalBranch6 key elt fm_L fm_R

  
mkBalBranch6 key elt fm_L fm_R = mkBalBranch6MkBalBranch5 key elt fm_L fm_R key elt fm_L fm_R (mkBalBranch6Size_l key elt fm_L fm_R + mkBalBranch6Size_r key elt fm_L fm_R < Pos (Succ (Succ Zero)))

  
mkBalBranch6Double_L yvz ywu ywv yww fm_l (Branch key_r elt_r vxx (Branch key_rl elt_rl vxy fm_rll fm_rlr) fm_rr) = mkBranch (Pos (Succ (Succ (Succ (Succ (Succ Zero)))))) key_rl elt_rl (mkBranch (Pos (Succ (Succ (Succ (Succ (Succ (Succ Zero))))))) yvz ywu fm_l fm_rll) (mkBranch (Pos (Succ (Succ (Succ (Succ (Succ (Succ (Succ Zero)))))))) key_r elt_r fm_rlr fm_rr)

  
mkBalBranch6Double_R yvz ywu ywv yww (Branch key_l elt_l vwy fm_ll (Branch key_lr elt_lr vwz fm_lrl fm_lrr)) fm_r = mkBranch (Pos (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ Zero))))))))))) key_lr elt_lr (mkBranch (Pos (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ Zero)))))))))))) key_l elt_l fm_ll fm_lrl) (mkBranch (Pos (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ Zero))))))))))))) yvz ywu fm_lrr fm_r)

  
mkBalBranch6MkBalBranch0 yvz ywu ywv yww fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr) = mkBalBranch6MkBalBranch02 yvz ywu ywv yww fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr)

  
mkBalBranch6MkBalBranch00 yvz ywu ywv yww fm_L fm_R vxz vyu vyv fm_rl fm_rr True = mkBalBranch6Double_L yvz ywu ywv yww fm_L fm_R

  
mkBalBranch6MkBalBranch01 yvz ywu ywv yww fm_L fm_R vxz vyu vyv fm_rl fm_rr True = mkBalBranch6Single_L yvz ywu ywv yww fm_L fm_R
mkBalBranch6MkBalBranch01 yvz ywu ywv yww fm_L fm_R vxz vyu vyv fm_rl fm_rr False = mkBalBranch6MkBalBranch00 yvz ywu ywv yww fm_L fm_R vxz vyu vyv fm_rl fm_rr otherwise

  
mkBalBranch6MkBalBranch02 yvz ywu ywv yww fm_L fm_R (Branch vxz vyu vyv fm_rl fm_rr) = mkBalBranch6MkBalBranch01 yvz ywu ywv yww fm_L fm_R vxz vyu vyv fm_rl fm_rr (sizeFM fm_rl < Pos (Succ (Succ Zero)) * sizeFM fm_rr)

  
mkBalBranch6MkBalBranch1 yvz ywu ywv yww fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr) = mkBalBranch6MkBalBranch12 yvz ywu ywv yww fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr)

  
mkBalBranch6MkBalBranch10 yvz ywu ywv yww fm_L fm_R vxu vxv vxw fm_ll fm_lr True = mkBalBranch6Double_R yvz ywu ywv yww fm_L fm_R

  
mkBalBranch6MkBalBranch11 yvz ywu ywv yww fm_L fm_R vxu vxv vxw fm_ll fm_lr True = mkBalBranch6Single_R yvz ywu ywv yww fm_L fm_R
mkBalBranch6MkBalBranch11 yvz ywu ywv yww fm_L fm_R vxu vxv vxw fm_ll fm_lr False = mkBalBranch6MkBalBranch10 yvz ywu ywv yww fm_L fm_R vxu vxv vxw fm_ll fm_lr otherwise

  
mkBalBranch6MkBalBranch12 yvz ywu ywv yww fm_L fm_R (Branch vxu vxv vxw fm_ll fm_lr) = mkBalBranch6MkBalBranch11 yvz ywu ywv yww fm_L fm_R vxu vxv vxw fm_ll fm_lr (sizeFM fm_lr < Pos (Succ (Succ Zero)) * sizeFM fm_ll)

  
mkBalBranch6MkBalBranch2 yvz ywu ywv yww key elt fm_L fm_R True = mkBranch (Pos (Succ (Succ Zero))) key elt fm_L fm_R

  
mkBalBranch6MkBalBranch3 yvz ywu ywv yww key elt fm_L fm_R True = mkBalBranch6MkBalBranch1 yvz ywu ywv yww fm_L fm_R fm_L
mkBalBranch6MkBalBranch3 yvz ywu ywv yww key elt fm_L fm_R False = mkBalBranch6MkBalBranch2 yvz ywu ywv yww key elt fm_L fm_R otherwise

  
mkBalBranch6MkBalBranch4 yvz ywu ywv yww key elt fm_L fm_R True = mkBalBranch6MkBalBranch0 yvz ywu ywv yww fm_L fm_R fm_R
mkBalBranch6MkBalBranch4 yvz ywu ywv yww key elt fm_L fm_R False = mkBalBranch6MkBalBranch3 yvz ywu ywv yww key elt fm_L fm_R (mkBalBranch6Size_l yvz ywu ywv yww > sIZE_RATIO * mkBalBranch6Size_r yvz ywu ywv yww)

  
mkBalBranch6MkBalBranch5 yvz ywu ywv yww key elt fm_L fm_R True = mkBranch (Pos (Succ Zero)) key elt fm_L fm_R
mkBalBranch6MkBalBranch5 yvz ywu ywv yww key elt fm_L fm_R False = mkBalBranch6MkBalBranch4 yvz ywu ywv yww key elt fm_L fm_R (mkBalBranch6Size_r yvz ywu ywv yww > sIZE_RATIO * mkBalBranch6Size_l yvz ywu ywv yww)

  
mkBalBranch6Single_L yvz ywu ywv yww fm_l (Branch key_r elt_r vyw fm_rl fm_rr) = mkBranch (Pos (Succ (Succ (Succ Zero)))) key_r elt_r (mkBranch (Pos (Succ (Succ (Succ (Succ Zero))))) yvz ywu fm_l fm_rl) fm_rr

  
mkBalBranch6Single_R yvz ywu ywv yww (Branch key_l elt_l vwx fm_ll fm_lr) fm_r = mkBranch (Pos (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ Zero))))))))) key_l elt_l fm_ll (mkBranch (Pos (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ Zero)))))))))) yvz ywu fm_lr fm_r)

  
mkBalBranch6Size_l yvz ywu ywv yww = sizeFM ywv

  
mkBalBranch6Size_r yvz ywu ywv yww = sizeFM yww

  mkBranch :: Ord b => Int  ->  b  ->  a  ->  FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
mkBranch which key elt fm_l fm_r = mkBranchResult key elt fm_r fm_l

  
mkBranchBalance_ok yyv yyw yyx = True

  
mkBranchLeft_ok yyv yyw yyx = mkBranchLeft_ok0 yyv yyw yyx yyx yyw yyx

  
mkBranchLeft_ok0 yyv yyw yyx fm_l key EmptyFM = True
mkBranchLeft_ok0 yyv yyw yyx fm_l key (Branch left_key vw vx vy vz) = mkBranchLeft_ok0Biggest_left_key fm_l < key

  
mkBranchLeft_ok0Biggest_left_key zvw = fst (findMax zvw)

  
mkBranchLeft_size yyv yyw yyx = sizeFM yyx

  
mkBranchResult yyy yyz yzu yzv = Branch yyy yyz (mkBranchUnbox yzu yyy yzv (Pos (Succ Zero) + mkBranchLeft_size yzu yyy yzv + mkBranchRight_size yzu yyy yzv)) yzv yzu

  
mkBranchRight_ok yyv yyw yyx = mkBranchRight_ok0 yyv yyw yyx yyv yyw yyv

  
mkBranchRight_ok0 yyv yyw yyx fm_r key EmptyFM = True
mkBranchRight_ok0 yyv yyw yyx fm_r key (Branch right_key wu wv ww wx) = key < mkBranchRight_ok0Smallest_right_key fm_r

  
mkBranchRight_ok0Smallest_right_key zvx = fst (findMin zvx)

  
mkBranchRight_size yyv yyw yyx = sizeFM yyv

  mkBranchUnbox :: Ord a =>  ->  (FiniteMap a b) ( ->  a ( ->  (FiniteMap a b) (Int  ->  Int)))
mkBranchUnbox yyv yyw yyx x = x

  mkVBalBranch :: Ord b => b  ->  a  ->  FiniteMap b a  ->  FiniteMap b a  ->  FiniteMap b a
mkVBalBranch key elt EmptyFM fm_r = mkVBalBranch5 key elt EmptyFM fm_r
mkVBalBranch key elt fm_l EmptyFM = mkVBalBranch4 key elt fm_l EmptyFM
mkVBalBranch key elt (Branch vuy vuz vvu vvv vvw) (Branch vvy vvz vwu vwv vww) = mkVBalBranch3 key elt (Branch vuy vuz vvu vvv vvw) (Branch vvy vvz vwu vwv vww)

  
mkVBalBranch3 key elt (Branch vuy vuz vvu vvv vvw) (Branch vvy vvz vwu vwv vww) = mkVBalBranch3MkVBalBranch2 vvy vvz vwu vwv vww vuy vuz vvu vvv vvw key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww (sIZE_RATIO * mkVBalBranch3Size_l vvy vvz vwu vwv vww vuy vuz vvu vvv vvw < mkVBalBranch3Size_r vvy vvz vwu vwv vww vuy vuz vvu vvv vvw)

  
mkVBalBranch3MkVBalBranch0 yzy yzz zuu zuv zuw zux zuy zuz zvu zvv key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww True = mkBranch (Pos (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ Zero)))))))))))))) key elt (Branch vuy vuz vvu vvv vvw) (Branch vvy vvz vwu vwv vww)

  
mkVBalBranch3MkVBalBranch1 yzy yzz zuu zuv zuw zux zuy zuz zvu zvv key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww True = mkBalBranch vuy vuz vvv (mkVBalBranch key elt vvw (Branch vvy vvz vwu vwv vww))
mkVBalBranch3MkVBalBranch1 yzy yzz zuu zuv zuw zux zuy zuz zvu zvv key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww False = mkVBalBranch3MkVBalBranch0 yzy yzz zuu zuv zuw zux zuy zuz zvu zvv key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww otherwise

  
mkVBalBranch3MkVBalBranch2 yzy yzz zuu zuv zuw zux zuy zuz zvu zvv key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww True = mkBalBranch vvy vvz (mkVBalBranch key elt (Branch vuy vuz vvu vvv vvw) vwv) vww
mkVBalBranch3MkVBalBranch2 yzy yzz zuu zuv zuw zux zuy zuz zvu zvv key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww False = mkVBalBranch3MkVBalBranch1 yzy yzz zuu zuv zuw zux zuy zuz zvu zvv key elt vuy vuz vvu vvv vvw vvy vvz vwu vwv vww (sIZE_RATIO * mkVBalBranch3Size_r yzy yzz zuu zuv zuw zux zuy zuz zvu zvv < mkVBalBranch3Size_l yzy yzz zuu zuv zuw zux zuy zuz zvu zvv)

  
mkVBalBranch3Size_l yzy yzz zuu zuv zuw zux zuy zuz zvu zvv = sizeFM (Branch zux zuy zuz zvu zvv)

  
mkVBalBranch3Size_r yzy yzz zuu zuv zuw zux zuy zuz zvu zvv = sizeFM (Branch yzy yzz zuu zuv zuw)

  
mkVBalBranch4 key elt fm_l EmptyFM = addToFM fm_l key elt
mkVBalBranch4 xuy xuz xvu xvv = mkVBalBranch3 xuy xuz xvu xvv

  
mkVBalBranch5 key elt EmptyFM fm_r = addToFM fm_r key elt
mkVBalBranch5 xvx xvy xvz xwu = mkVBalBranch4 xvx xvy xvz xwu

  sIZE_RATIO :: Int
sIZE_RATIO = Pos (Succ (Succ (Succ (Succ (Succ Zero)))))

  sizeFM :: FiniteMap a b  ->  Int
sizeFM EmptyFM = Pos Zero
sizeFM (Branch xx xy size xz yu) = size

  unitFM :: b  ->  a  ->  FiniteMap b a
unitFM key elt = Branch key elt (Pos (Succ Zero)) emptyFM emptyFM


module Maybe where
  import qualified FiniteMap
import qualified Prelude


Haskell To QDPs


↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primEqNat(Succ(zwu40000), Succ(zwu60000)) → new_primEqNat(zwu40000, zwu60000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueBal2Mid_elt20(zwu314, zwu315, zwu316, zwu317, zwu318, zwu319, zwu320, zwu321, zwu322, zwu323, zwu324, zwu325, zwu326, Branch(zwu3270, zwu3271, zwu3272, zwu3273, zwu3274), zwu328, h, ba) → new_glueBal2Mid_elt20(zwu314, zwu315, zwu316, zwu317, zwu318, zwu319, zwu320, zwu321, zwu322, zwu323, zwu3270, zwu3271, zwu3272, zwu3273, zwu3274, h, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueBal2Mid_key20(zwu298, zwu299, zwu300, zwu301, zwu302, zwu303, zwu304, zwu305, zwu306, zwu307, zwu308, zwu309, zwu310, Branch(zwu3110, zwu3111, zwu3112, zwu3113, zwu3114), zwu312, h, ba) → new_glueBal2Mid_key20(zwu298, zwu299, zwu300, zwu301, zwu302, zwu303, zwu304, zwu305, zwu306, zwu307, zwu3110, zwu3111, zwu3112, zwu3113, zwu3114, h, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueBal2Mid_elt10(zwu346, zwu347, zwu348, zwu349, zwu350, zwu351, zwu352, zwu353, zwu354, zwu355, zwu356, zwu357, zwu358, zwu359, Branch(zwu3600, zwu3601, zwu3602, zwu3603, zwu3604), h, ba) → new_glueBal2Mid_elt10(zwu346, zwu347, zwu348, zwu349, zwu350, zwu351, zwu352, zwu353, zwu354, zwu355, zwu3600, zwu3601, zwu3602, zwu3603, zwu3604, h, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueBal2Mid_key10(zwu330, zwu331, zwu332, zwu333, zwu334, zwu335, zwu336, zwu337, zwu338, zwu339, zwu340, zwu341, zwu342, zwu343, Branch(zwu3440, zwu3441, zwu3442, zwu3443, zwu3444), h, ba) → new_glueBal2Mid_key10(zwu330, zwu331, zwu332, zwu333, zwu334, zwu335, zwu336, zwu337, zwu338, zwu339, zwu3440, zwu3441, zwu3442, zwu3443, zwu3444, h, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primCmpNat(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat(zwu4000, zwu6000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primMinusNat(Succ(zwu44200), Succ(zwu12200)) → new_primMinusNat(zwu44200, zwu12200)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primPlusNat(Succ(zwu44200), Succ(zwu12200)) → new_primPlusNat(zwu44200, zwu12200)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primMulNat(Succ(zwu40000), Succ(zwu60100)) → new_primMulNat(zwu40000, Succ(zwu60100))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_esEs(@3(zwu4000, zwu4001, zwu4002), @3(zwu6000, zwu6001, zwu6002), cc, bc, app(ty_[], eb)) → new_esEs1(zwu4002, zwu6002, eb)
new_esEs3(Right(zwu4000), Right(zwu6000), bda, app(app(ty_@2, bdg), bdh)) → new_esEs2(zwu4000, zwu6000, bdg, bdh)
new_esEs(@3(zwu4000, zwu4001, zwu4002), @3(zwu6000, zwu6001, zwu6002), app(app(ty_Either, ca), cb), bc, bd) → new_esEs3(zwu4000, zwu6000, ca, cb)
new_esEs0(Just(zwu4000), Just(zwu6000), app(app(ty_Either, fg), fh)) → new_esEs3(zwu4000, zwu6000, fg, fh)
new_esEs2(@2(zwu4000, zwu4001), @2(zwu6000, zwu6001), bae, app(app(ty_@2, bbc), bbd)) → new_esEs2(zwu4001, zwu6001, bbc, bbd)
new_esEs(@3(zwu4000, zwu4001, zwu4002), @3(zwu6000, zwu6001, zwu6002), app(ty_Maybe, be), bc, bd) → new_esEs0(zwu4000, zwu6000, be)
new_esEs3(Right(zwu4000), Right(zwu6000), bda, app(app(ty_Either, bea), beb)) → new_esEs3(zwu4000, zwu6000, bea, beb)
new_esEs1(:(zwu4000, zwu4001), :(zwu6000, zwu6001), hb) → new_esEs1(zwu4001, zwu6001, hb)
new_esEs0(Just(zwu4000), Just(zwu6000), app(ty_Maybe, fb)) → new_esEs0(zwu4000, zwu6000, fb)
new_esEs2(@2(zwu4000, zwu4001), @2(zwu6000, zwu6001), app(app(ty_@2, baa), bab), hf) → new_esEs2(zwu4000, zwu6000, baa, bab)
new_esEs2(@2(zwu4000, zwu4001), @2(zwu6000, zwu6001), bae, app(ty_Maybe, bba)) → new_esEs0(zwu4001, zwu6001, bba)
new_esEs(@3(zwu4000, zwu4001, zwu4002), @3(zwu6000, zwu6001, zwu6002), cc, app(ty_[], da), bd) → new_esEs1(zwu4001, zwu6001, da)
new_esEs(@3(zwu4000, zwu4001, zwu4002), @3(zwu6000, zwu6001, zwu6002), app(app(app(ty_@3, h), ba), bb), bc, bd) → new_esEs(zwu4000, zwu6000, h, ba, bb)
new_esEs1(:(zwu4000, zwu4001), :(zwu6000, zwu6001), app(ty_[], ge)) → new_esEs1(zwu4000, zwu6000, ge)
new_esEs2(@2(zwu4000, zwu4001), @2(zwu6000, zwu6001), bae, app(app(app(ty_@3, baf), bag), bah)) → new_esEs(zwu4001, zwu6001, baf, bag, bah)
new_esEs3(Left(zwu4000), Left(zwu6000), app(app(ty_Either, bcg), bch), bcb) → new_esEs3(zwu4000, zwu6000, bcg, bch)
new_esEs2(@2(zwu4000, zwu4001), @2(zwu6000, zwu6001), app(ty_[], hh), hf) → new_esEs1(zwu4000, zwu6000, hh)
new_esEs2(@2(zwu4000, zwu4001), @2(zwu6000, zwu6001), app(ty_Maybe, hg), hf) → new_esEs0(zwu4000, zwu6000, hg)
new_esEs(@3(zwu4000, zwu4001, zwu4002), @3(zwu6000, zwu6001, zwu6002), app(ty_[], bf), bc, bd) → new_esEs1(zwu4000, zwu6000, bf)
new_esEs1(:(zwu4000, zwu4001), :(zwu6000, zwu6001), app(app(ty_Either, gh), ha)) → new_esEs3(zwu4000, zwu6000, gh, ha)
new_esEs(@3(zwu4000, zwu4001, zwu4002), @3(zwu6000, zwu6001, zwu6002), app(app(ty_@2, bg), bh), bc, bd) → new_esEs2(zwu4000, zwu6000, bg, bh)
new_esEs(@3(zwu4000, zwu4001, zwu4002), @3(zwu6000, zwu6001, zwu6002), cc, app(ty_Maybe, cg), bd) → new_esEs0(zwu4001, zwu6001, cg)
new_esEs3(Right(zwu4000), Right(zwu6000), bda, app(app(app(ty_@3, bdb), bdc), bdd)) → new_esEs(zwu4000, zwu6000, bdb, bdc, bdd)
new_esEs3(Left(zwu4000), Left(zwu6000), app(app(ty_@2, bce), bcf), bcb) → new_esEs2(zwu4000, zwu6000, bce, bcf)
new_esEs0(Just(zwu4000), Just(zwu6000), app(app(ty_@2, fd), ff)) → new_esEs2(zwu4000, zwu6000, fd, ff)
new_esEs2(@2(zwu4000, zwu4001), @2(zwu6000, zwu6001), app(app(app(ty_@3, hc), hd), he), hf) → new_esEs(zwu4000, zwu6000, hc, hd, he)
new_esEs0(Just(zwu4000), Just(zwu6000), app(ty_[], fc)) → new_esEs1(zwu4000, zwu6000, fc)
new_esEs1(:(zwu4000, zwu4001), :(zwu6000, zwu6001), app(ty_Maybe, gd)) → new_esEs0(zwu4000, zwu6000, gd)
new_esEs2(@2(zwu4000, zwu4001), @2(zwu6000, zwu6001), bae, app(app(ty_Either, bbe), bbf)) → new_esEs3(zwu4001, zwu6001, bbe, bbf)
new_esEs(@3(zwu4000, zwu4001, zwu4002), @3(zwu6000, zwu6001, zwu6002), cc, app(app(ty_@2, db), dc), bd) → new_esEs2(zwu4001, zwu6001, db, dc)
new_esEs3(Right(zwu4000), Right(zwu6000), bda, app(ty_[], bdf)) → new_esEs1(zwu4000, zwu6000, bdf)
new_esEs(@3(zwu4000, zwu4001, zwu4002), @3(zwu6000, zwu6001, zwu6002), cc, app(app(app(ty_@3, cd), ce), cf), bd) → new_esEs(zwu4001, zwu6001, cd, ce, cf)
new_esEs(@3(zwu4000, zwu4001, zwu4002), @3(zwu6000, zwu6001, zwu6002), cc, bc, app(ty_Maybe, ea)) → new_esEs0(zwu4002, zwu6002, ea)
new_esEs0(Just(zwu4000), Just(zwu6000), app(app(app(ty_@3, eg), eh), fa)) → new_esEs(zwu4000, zwu6000, eg, eh, fa)
new_esEs1(:(zwu4000, zwu4001), :(zwu6000, zwu6001), app(app(app(ty_@3, ga), gb), gc)) → new_esEs(zwu4000, zwu6000, ga, gb, gc)
new_esEs(@3(zwu4000, zwu4001, zwu4002), @3(zwu6000, zwu6001, zwu6002), cc, bc, app(app(ty_@2, ec), ed)) → new_esEs2(zwu4002, zwu6002, ec, ed)
new_esEs1(:(zwu4000, zwu4001), :(zwu6000, zwu6001), app(app(ty_@2, gf), gg)) → new_esEs2(zwu4000, zwu6000, gf, gg)
new_esEs(@3(zwu4000, zwu4001, zwu4002), @3(zwu6000, zwu6001, zwu6002), cc, app(app(ty_Either, dd), de), bd) → new_esEs3(zwu4001, zwu6001, dd, de)
new_esEs2(@2(zwu4000, zwu4001), @2(zwu6000, zwu6001), bae, app(ty_[], bbb)) → new_esEs1(zwu4001, zwu6001, bbb)
new_esEs2(@2(zwu4000, zwu4001), @2(zwu6000, zwu6001), app(app(ty_Either, bac), bad), hf) → new_esEs3(zwu4000, zwu6000, bac, bad)
new_esEs3(Left(zwu4000), Left(zwu6000), app(ty_Maybe, bcc), bcb) → new_esEs0(zwu4000, zwu6000, bcc)
new_esEs3(Left(zwu4000), Left(zwu6000), app(ty_[], bcd), bcb) → new_esEs1(zwu4000, zwu6000, bcd)
new_esEs3(Right(zwu4000), Right(zwu6000), bda, app(ty_Maybe, bde)) → new_esEs0(zwu4000, zwu6000, bde)
new_esEs3(Left(zwu4000), Left(zwu6000), app(app(app(ty_@3, bbg), bbh), bca), bcb) → new_esEs(zwu4000, zwu6000, bbg, bbh, bca)
new_esEs(@3(zwu4000, zwu4001, zwu4002), @3(zwu6000, zwu6001, zwu6002), cc, bc, app(app(ty_Either, ee), ef)) → new_esEs3(zwu4002, zwu6002, ee, ef)
new_esEs(@3(zwu4000, zwu4001, zwu4002), @3(zwu6000, zwu6001, zwu6002), cc, bc, app(app(app(ty_@3, df), dg), dh)) → new_esEs(zwu4002, zwu6002, df, dg, dh)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_ltEs2(@2(zwu730, zwu731), @2(zwu740, zwu741), app(ty_Maybe, bag), bah) → new_lt(zwu730, zwu740, bag)
new_ltEs2(@2(zwu730, zwu731), @2(zwu740, zwu741), app(app(ty_@2, bbe), bbf), bah) → new_lt2(zwu730, zwu740, bbe, bbf)
new_compare20(@2(zwu730, zwu731), @2(zwu740, zwu741), False, app(app(ty_@2, app(ty_[], bbd)), bah)) → new_lt1(zwu730, zwu740, bbd)
new_compare20(@2(zwu730, zwu731), @2(zwu740, zwu741), False, app(app(ty_@2, he), app(ty_Maybe, hf))) → new_ltEs(zwu731, zwu741, hf)
new_ltEs3(Left(zwu730), Left(zwu740), app(app(ty_Either, bda), bdb), bcb) → new_ltEs3(zwu730, zwu740, bda, bdb)
new_compare20(Right(zwu730), Right(zwu740), False, app(app(ty_Either, bdc), app(app(ty_Either, bec), bed))) → new_ltEs3(zwu730, zwu740, bec, bed)
new_compare20(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), False, app(app(app(ty_@3, ca), cb), app(ty_Maybe, cc))) → new_ltEs(zwu732, zwu742, cc)
new_compare20(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), False, app(app(app(ty_@3, app(ty_Maybe, eg)), cb), df)) → new_lt(zwu730, zwu740, eg)
new_compare22(zwu149, zwu150, zwu151, zwu152, False, ccb, app(app(ty_@2, cch), cda)) → new_ltEs2(zwu150, zwu152, cch, cda)
new_compare21(zwu136, zwu137, zwu138, zwu139, zwu140, zwu141, False, bgc, app(app(app(ty_@3, bhf), bhg), bhh), bfb) → new_lt0(zwu137, zwu140, bhf, bhg, bhh)
new_ltEs2(@2(zwu730, zwu731), @2(zwu740, zwu741), he, app(ty_Maybe, hf)) → new_ltEs(zwu731, zwu741, hf)
new_compare20(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), False, app(app(app(ty_@3, app(app(app(ty_@3, eh), fa), fb)), cb), df)) → new_lt0(zwu730, zwu740, eh, fa, fb)
new_compare20(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), False, app(app(app(ty_@3, ca), cb), app(app(ty_Either, dc), dd))) → new_ltEs3(zwu732, zwu742, dc, dd)
new_compare20(Just(zwu730), Just(zwu740), False, app(ty_Maybe, app(app(ty_Either, bg), bh))) → new_ltEs3(zwu730, zwu740, bg, bh)
new_compare21(zwu136, zwu137, zwu138, zwu139, zwu140, zwu141, False, bgc, app(ty_[], caa), bfb) → new_lt1(zwu137, zwu140, caa)
new_compare24(zwu118, zwu119, False, ceh, app(ty_Maybe, cfa)) → new_ltEs(zwu118, zwu119, cfa)
new_compare21(zwu136, zwu137, zwu138, zwu139, zwu140, zwu141, False, bgc, app(app(ty_@2, cab), cac), bfb) → new_lt2(zwu137, zwu140, cab, cac)
new_compare20(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), False, app(app(app(ty_@3, app(ty_[], fc)), cb), df)) → new_lt1(zwu730, zwu740, fc)
new_compare20(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), False, app(app(app(ty_@3, ca), app(app(ty_@2, ec), ed)), df)) → new_lt2(zwu731, zwu741, ec, ed)
new_ltEs0(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), app(app(ty_@2, fd), ff), cb, df) → new_lt2(zwu730, zwu740, fd, ff)
new_ltEs3(Left(zwu730), Left(zwu740), app(ty_Maybe, bca), bcb) → new_ltEs(zwu730, zwu740, bca)
new_lt1(:(zwu400, zwu401), :(zwu600, zwu601), gb) → new_primCompAux(zwu400, zwu600, new_compare0(zwu401, zwu601, gb), gb)
new_compare20(Right(zwu730), Right(zwu740), False, app(app(ty_Either, bdc), app(app(ty_@2, bea), beb))) → new_ltEs2(zwu730, zwu740, bea, beb)
new_ltEs3(Right(zwu730), Right(zwu740), bdc, app(app(app(ty_@3, bde), bdf), bdg)) → new_ltEs0(zwu730, zwu740, bde, bdf, bdg)
new_compare20(Just(zwu730), Just(zwu740), False, app(ty_Maybe, app(app(app(ty_@3, ba), bb), bc))) → new_ltEs0(zwu730, zwu740, ba, bb, bc)
new_ltEs(Just(zwu730), Just(zwu740), app(app(ty_Either, bg), bh)) → new_ltEs3(zwu730, zwu740, bg, bh)
new_primCompAux(zwu400, zwu600, zwu57, app(ty_[], gg)) → new_compare(zwu400, zwu600, gg)
new_compare21(zwu136, zwu137, zwu138, zwu139, zwu140, zwu141, False, app(ty_[], bff), bfa, bfb) → new_lt1(zwu136, zwu139, bff)
new_compare20(Just(zwu730), Just(zwu740), False, app(ty_Maybe, app(app(ty_@2, be), bf))) → new_ltEs2(zwu730, zwu740, be, bf)
new_compare1(Just(zwu400), Just(zwu600), hd) → new_compare20(zwu400, zwu600, new_esEs4(zwu400, zwu600, hd), hd)
new_compare20(@2(zwu730, zwu731), @2(zwu740, zwu741), False, app(app(ty_@2, he), app(app(app(ty_@3, hg), hh), baa))) → new_ltEs0(zwu731, zwu741, hg, hh, baa)
new_compare24(zwu118, zwu119, False, ceh, app(app(ty_Either, cfh), cga)) → new_ltEs3(zwu118, zwu119, cfh, cga)
new_compare20(zwu73, zwu74, False, app(ty_[], ga)) → new_compare(zwu73, zwu74, ga)
new_compare22(zwu149, zwu150, zwu151, zwu152, False, app(app(ty_@2, cbf), cbg), cba) → new_lt2(zwu149, zwu151, cbf, cbg)
new_compare20(@2(zwu730, zwu731), @2(zwu740, zwu741), False, app(app(ty_@2, app(app(ty_Either, bbg), bbh)), bah)) → new_lt3(zwu730, zwu740, bbg, bbh)
new_lt2(@2(zwu400, zwu401), @2(zwu600, zwu601), caf, cag) → new_compare22(zwu400, zwu401, zwu600, zwu601, new_asAs(new_esEs8(zwu400, zwu600, caf), new_esEs9(zwu401, zwu601, cag)), caf, cag)
new_compare20(Right(zwu730), Right(zwu740), False, app(app(ty_Either, bdc), app(app(app(ty_@3, bde), bdf), bdg))) → new_ltEs0(zwu730, zwu740, bde, bdf, bdg)
new_lt1(:(zwu400, zwu401), :(zwu600, zwu601), gb) → new_compare(zwu401, zwu601, gb)
new_ltEs3(Right(zwu730), Right(zwu740), bdc, app(app(ty_Either, bec), bed)) → new_ltEs3(zwu730, zwu740, bec, bed)
new_compare20(Left(zwu730), Left(zwu740), False, app(app(ty_Either, app(app(ty_@2, bcg), bch)), bcb)) → new_ltEs2(zwu730, zwu740, bcg, bch)
new_ltEs0(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), ca, app(app(ty_@2, ec), ed), df) → new_lt2(zwu731, zwu741, ec, ed)
new_lt3(Right(zwu400), Right(zwu600), cdd, cde) → new_compare24(zwu400, zwu600, new_esEs11(zwu400, zwu600, cde), cdd, cde)
new_ltEs(Just(zwu730), Just(zwu740), app(app(app(ty_@3, ba), bb), bc)) → new_ltEs0(zwu730, zwu740, ba, bb, bc)
new_compare21(zwu136, zwu137, zwu138, zwu139, zwu140, zwu141, False, bgc, bfa, app(app(ty_@2, bha), bhb)) → new_ltEs2(zwu138, zwu141, bha, bhb)
new_ltEs0(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), app(ty_[], fc), cb, df) → new_lt1(zwu730, zwu740, fc)
new_ltEs0(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), ca, cb, app(app(app(ty_@3, cd), ce), cf)) → new_ltEs0(zwu732, zwu742, cd, ce, cf)
new_ltEs0(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), ca, cb, app(ty_[], cg)) → new_ltEs1(zwu732, zwu742, cg)
new_compare23(zwu111, zwu112, False, app(app(ty_Either, cef), ceg), cdg) → new_ltEs3(zwu111, zwu112, cef, ceg)
new_ltEs2(@2(zwu730, zwu731), @2(zwu740, zwu741), app(app(app(ty_@3, bba), bbb), bbc), bah) → new_lt0(zwu730, zwu740, bba, bbb, bbc)
new_ltEs0(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), ca, cb, app(app(ty_@2, da), db)) → new_ltEs2(zwu732, zwu742, da, db)
new_ltEs(Just(zwu730), Just(zwu740), app(ty_[], bd)) → new_ltEs1(zwu730, zwu740, bd)
new_primCompAux(zwu400, zwu600, zwu57, app(ty_Maybe, gc)) → new_compare1(zwu400, zwu600, gc)
new_compare3(@2(zwu400, zwu401), @2(zwu600, zwu601), caf, cag) → new_compare22(zwu400, zwu401, zwu600, zwu601, new_asAs(new_esEs8(zwu400, zwu600, caf), new_esEs9(zwu401, zwu601, cag)), caf, cag)
new_compare20(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), False, app(app(app(ty_@3, app(app(ty_Either, fg), fh)), cb), df)) → new_lt3(zwu730, zwu740, fg, fh)
new_ltEs2(@2(zwu730, zwu731), @2(zwu740, zwu741), he, app(ty_[], bab)) → new_ltEs1(zwu731, zwu741, bab)
new_compare21(zwu136, zwu137, zwu138, zwu139, zwu140, zwu141, False, bgc, app(app(ty_Either, cad), cae), bfb) → new_lt3(zwu137, zwu140, cad, cae)
new_ltEs3(Left(zwu730), Left(zwu740), app(ty_[], bcf), bcb) → new_ltEs1(zwu730, zwu740, bcf)
new_ltEs0(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), ca, cb, app(ty_Maybe, cc)) → new_ltEs(zwu732, zwu742, cc)
new_compare21(zwu136, zwu137, zwu138, zwu139, zwu140, zwu141, False, app(app(ty_@2, bfg), bfh), bfa, bfb) → new_lt2(zwu136, zwu139, bfg, bfh)
new_compare22(zwu149, zwu150, zwu151, zwu152, False, app(ty_Maybe, cah), cba) → new_lt(zwu149, zwu151, cah)
new_ltEs2(@2(zwu730, zwu731), @2(zwu740, zwu741), he, app(app(app(ty_@3, hg), hh), baa)) → new_ltEs0(zwu731, zwu741, hg, hh, baa)
new_ltEs0(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), app(app(ty_Either, fg), fh), cb, df) → new_lt3(zwu730, zwu740, fg, fh)
new_compare22(zwu149, zwu150, zwu151, zwu152, False, ccb, app(app(ty_Either, cdb), cdc)) → new_ltEs3(zwu150, zwu152, cdb, cdc)
new_ltEs0(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), ca, app(ty_[], eb), df) → new_lt1(zwu731, zwu741, eb)
new_lt0(@3(zwu400, zwu401, zwu402), @3(zwu600, zwu601, zwu602), bee, bef, beg) → new_compare21(zwu400, zwu401, zwu402, zwu600, zwu601, zwu602, new_asAs(new_esEs5(zwu400, zwu600, bee), new_asAs(new_esEs6(zwu401, zwu601, bef), new_esEs7(zwu402, zwu602, beg))), bee, bef, beg)
new_ltEs2(@2(zwu730, zwu731), @2(zwu740, zwu741), he, app(app(ty_Either, bae), baf)) → new_ltEs3(zwu731, zwu741, bae, baf)
new_compare23(zwu111, zwu112, False, app(ty_Maybe, cdf), cdg) → new_ltEs(zwu111, zwu112, cdf)
new_ltEs2(@2(zwu730, zwu731), @2(zwu740, zwu741), app(ty_[], bbd), bah) → new_lt1(zwu730, zwu740, bbd)
new_compare20(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), False, app(app(app(ty_@3, ca), cb), app(app(ty_@2, da), db))) → new_ltEs2(zwu732, zwu742, da, db)
new_compare20(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), False, app(app(app(ty_@3, ca), app(ty_Maybe, de)), df)) → new_lt(zwu731, zwu741, de)
new_ltEs0(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), ca, cb, app(app(ty_Either, dc), dd)) → new_ltEs3(zwu732, zwu742, dc, dd)
new_compare21(zwu136, zwu137, zwu138, zwu139, zwu140, zwu141, False, bgc, bfa, app(app(app(ty_@3, bge), bgf), bgg)) → new_ltEs0(zwu138, zwu141, bge, bgf, bgg)
new_compare20(@2(zwu730, zwu731), @2(zwu740, zwu741), False, app(app(ty_@2, he), app(app(ty_@2, bac), bad))) → new_ltEs2(zwu731, zwu741, bac, bad)
new_compare20(Left(zwu730), Left(zwu740), False, app(app(ty_Either, app(app(ty_Either, bda), bdb)), bcb)) → new_ltEs3(zwu730, zwu740, bda, bdb)
new_compare21(zwu136, zwu137, zwu138, zwu139, zwu140, zwu141, False, app(app(app(ty_@3, bfc), bfd), bfe), bfa, bfb) → new_lt0(zwu136, zwu139, bfc, bfd, bfe)
new_compare20(@2(zwu730, zwu731), @2(zwu740, zwu741), False, app(app(ty_@2, he), app(ty_[], bab))) → new_ltEs1(zwu731, zwu741, bab)
new_compare24(zwu118, zwu119, False, ceh, app(app(ty_@2, cff), cfg)) → new_ltEs2(zwu118, zwu119, cff, cfg)
new_compare4(Right(zwu400), Right(zwu600), cdd, cde) → new_compare24(zwu400, zwu600, new_esEs11(zwu400, zwu600, cde), cdd, cde)
new_primCompAux(zwu400, zwu600, zwu57, app(app(ty_@2, gh), ha)) → new_compare3(zwu400, zwu600, gh, ha)
new_ltEs0(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), app(app(app(ty_@3, eh), fa), fb), cb, df) → new_lt0(zwu730, zwu740, eh, fa, fb)
new_ltEs1(zwu73, zwu74, ga) → new_compare(zwu73, zwu74, ga)
new_compare21(zwu136, zwu137, zwu138, zwu139, zwu140, zwu141, False, bgc, bfa, app(ty_Maybe, bgd)) → new_ltEs(zwu138, zwu141, bgd)
new_compare20(Just(zwu730), Just(zwu740), False, app(ty_Maybe, app(ty_[], bd))) → new_ltEs1(zwu730, zwu740, bd)
new_compare20(Right(zwu730), Right(zwu740), False, app(app(ty_Either, bdc), app(ty_Maybe, bdd))) → new_ltEs(zwu730, zwu740, bdd)
new_compare22(zwu149, zwu150, zwu151, zwu152, False, app(app(app(ty_@3, cbb), cbc), cbd), cba) → new_lt0(zwu149, zwu151, cbb, cbc, cbd)
new_lt(Just(zwu400), Just(zwu600), hd) → new_compare20(zwu400, zwu600, new_esEs4(zwu400, zwu600, hd), hd)
new_ltEs2(@2(zwu730, zwu731), @2(zwu740, zwu741), app(app(ty_Either, bbg), bbh), bah) → new_lt3(zwu730, zwu740, bbg, bbh)
new_compare24(zwu118, zwu119, False, ceh, app(ty_[], cfe)) → new_ltEs1(zwu118, zwu119, cfe)
new_compare20(@2(zwu730, zwu731), @2(zwu740, zwu741), False, app(app(ty_@2, app(app(app(ty_@3, bba), bbb), bbc)), bah)) → new_lt0(zwu730, zwu740, bba, bbb, bbc)
new_compare20(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), False, app(app(app(ty_@3, ca), app(app(app(ty_@3, dg), dh), ea)), df)) → new_lt0(zwu731, zwu741, dg, dh, ea)
new_ltEs(Just(zwu730), Just(zwu740), app(ty_Maybe, h)) → new_ltEs(zwu730, zwu740, h)
new_compare22(zwu149, zwu150, zwu151, zwu152, False, app(ty_[], cbe), cba) → new_lt1(zwu149, zwu151, cbe)
new_ltEs3(Right(zwu730), Right(zwu740), bdc, app(app(ty_@2, bea), beb)) → new_ltEs2(zwu730, zwu740, bea, beb)
new_compare21(zwu136, zwu137, zwu138, zwu139, zwu140, zwu141, False, bgc, app(ty_Maybe, bhe), bfb) → new_lt(zwu137, zwu140, bhe)
new_ltEs(Just(zwu730), Just(zwu740), app(app(ty_@2, be), bf)) → new_ltEs2(zwu730, zwu740, be, bf)
new_compare22(zwu149, zwu150, zwu151, zwu152, False, ccb, app(ty_[], ccg)) → new_ltEs1(zwu150, zwu152, ccg)
new_compare20(Right(zwu730), Right(zwu740), False, app(app(ty_Either, bdc), app(ty_[], bdh))) → new_ltEs1(zwu730, zwu740, bdh)
new_compare20(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), False, app(app(app(ty_@3, ca), app(ty_[], eb)), df)) → new_lt1(zwu731, zwu741, eb)
new_ltEs0(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), ca, app(app(app(ty_@3, dg), dh), ea), df) → new_lt0(zwu731, zwu741, dg, dh, ea)
new_compare20(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), False, app(app(app(ty_@3, app(app(ty_@2, fd), ff)), cb), df)) → new_lt2(zwu730, zwu740, fd, ff)
new_compare22(zwu149, zwu150, zwu151, zwu152, False, ccb, app(app(app(ty_@3, ccd), cce), ccf)) → new_ltEs0(zwu150, zwu152, ccd, cce, ccf)
new_compare20(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), False, app(app(app(ty_@3, ca), app(app(ty_Either, ee), ef)), df)) → new_lt3(zwu731, zwu741, ee, ef)
new_primCompAux(zwu400, zwu600, zwu57, app(app(ty_Either, hb), hc)) → new_compare4(zwu400, zwu600, hb, hc)
new_compare24(zwu118, zwu119, False, ceh, app(app(app(ty_@3, cfb), cfc), cfd)) → new_ltEs0(zwu118, zwu119, cfb, cfc, cfd)
new_ltEs3(Right(zwu730), Right(zwu740), bdc, app(ty_[], bdh)) → new_ltEs1(zwu730, zwu740, bdh)
new_compare20(@2(zwu730, zwu731), @2(zwu740, zwu741), False, app(app(ty_@2, he), app(app(ty_Either, bae), baf))) → new_ltEs3(zwu731, zwu741, bae, baf)
new_ltEs3(Left(zwu730), Left(zwu740), app(app(ty_@2, bcg), bch), bcb) → new_ltEs2(zwu730, zwu740, bcg, bch)
new_compare21(zwu136, zwu137, zwu138, zwu139, zwu140, zwu141, False, app(app(ty_Either, bga), bgb), bfa, bfb) → new_lt3(zwu136, zwu139, bga, bgb)
new_ltEs2(@2(zwu730, zwu731), @2(zwu740, zwu741), he, app(app(ty_@2, bac), bad)) → new_ltEs2(zwu731, zwu741, bac, bad)
new_compare21(zwu136, zwu137, zwu138, zwu139, zwu140, zwu141, False, bgc, bfa, app(app(ty_Either, bhc), bhd)) → new_ltEs3(zwu138, zwu141, bhc, bhd)
new_compare20(@2(zwu730, zwu731), @2(zwu740, zwu741), False, app(app(ty_@2, app(app(ty_@2, bbe), bbf)), bah)) → new_lt2(zwu730, zwu740, bbe, bbf)
new_compare(:(zwu400, zwu401), :(zwu600, zwu601), gb) → new_compare(zwu401, zwu601, gb)
new_compare20(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), False, app(app(app(ty_@3, ca), cb), app(ty_[], cg))) → new_ltEs1(zwu732, zwu742, cg)
new_compare20(Left(zwu730), Left(zwu740), False, app(app(ty_Either, app(app(app(ty_@3, bcc), bcd), bce)), bcb)) → new_ltEs0(zwu730, zwu740, bcc, bcd, bce)
new_compare(:(zwu400, zwu401), :(zwu600, zwu601), gb) → new_primCompAux(zwu400, zwu600, new_compare0(zwu401, zwu601, gb), gb)
new_ltEs0(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), app(ty_Maybe, eg), cb, df) → new_lt(zwu730, zwu740, eg)
new_compare4(Left(zwu400), Left(zwu600), cdd, cde) → new_compare23(zwu400, zwu600, new_esEs10(zwu400, zwu600, cdd), cdd, cde)
new_compare20(Left(zwu730), Left(zwu740), False, app(app(ty_Either, app(ty_[], bcf)), bcb)) → new_ltEs1(zwu730, zwu740, bcf)
new_compare20(Just(zwu730), Just(zwu740), False, app(ty_Maybe, app(ty_Maybe, h))) → new_ltEs(zwu730, zwu740, h)
new_lt3(Left(zwu400), Left(zwu600), cdd, cde) → new_compare23(zwu400, zwu600, new_esEs10(zwu400, zwu600, cdd), cdd, cde)
new_compare20(Left(zwu730), Left(zwu740), False, app(app(ty_Either, app(ty_Maybe, bca)), bcb)) → new_ltEs(zwu730, zwu740, bca)
new_compare21(zwu136, zwu137, zwu138, zwu139, zwu140, zwu141, False, bgc, bfa, app(ty_[], bgh)) → new_ltEs1(zwu138, zwu141, bgh)
new_compare23(zwu111, zwu112, False, app(ty_[], cec), cdg) → new_ltEs1(zwu111, zwu112, cec)
new_ltEs3(Right(zwu730), Right(zwu740), bdc, app(ty_Maybe, bdd)) → new_ltEs(zwu730, zwu740, bdd)
new_compare22(zwu149, zwu150, zwu151, zwu152, False, app(app(ty_Either, cbh), cca), cba) → new_lt3(zwu149, zwu151, cbh, cca)
new_primCompAux(zwu400, zwu600, zwu57, app(app(app(ty_@3, gd), ge), gf)) → new_compare2(zwu400, zwu600, gd, ge, gf)
new_compare22(zwu149, zwu150, zwu151, zwu152, False, ccb, app(ty_Maybe, ccc)) → new_ltEs(zwu150, zwu152, ccc)
new_ltEs0(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), ca, app(app(ty_Either, ee), ef), df) → new_lt3(zwu731, zwu741, ee, ef)
new_compare20(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), False, app(app(app(ty_@3, ca), cb), app(app(app(ty_@3, cd), ce), cf))) → new_ltEs0(zwu732, zwu742, cd, ce, cf)
new_compare2(@3(zwu400, zwu401, zwu402), @3(zwu600, zwu601, zwu602), bee, bef, beg) → new_compare21(zwu400, zwu401, zwu402, zwu600, zwu601, zwu602, new_asAs(new_esEs5(zwu400, zwu600, bee), new_asAs(new_esEs6(zwu401, zwu601, bef), new_esEs7(zwu402, zwu602, beg))), bee, bef, beg)
new_compare23(zwu111, zwu112, False, app(app(ty_@2, ced), cee), cdg) → new_ltEs2(zwu111, zwu112, ced, cee)
new_ltEs3(Left(zwu730), Left(zwu740), app(app(app(ty_@3, bcc), bcd), bce), bcb) → new_ltEs0(zwu730, zwu740, bcc, bcd, bce)
new_compare21(zwu136, zwu137, zwu138, zwu139, zwu140, zwu141, False, app(ty_Maybe, beh), bfa, bfb) → new_lt(zwu136, zwu139, beh)
new_compare20(@2(zwu730, zwu731), @2(zwu740, zwu741), False, app(app(ty_@2, app(ty_Maybe, bag)), bah)) → new_lt(zwu730, zwu740, bag)
new_ltEs0(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), ca, app(ty_Maybe, de), df) → new_lt(zwu731, zwu741, de)
new_compare23(zwu111, zwu112, False, app(app(app(ty_@3, cdh), cea), ceb), cdg) → new_ltEs0(zwu111, zwu112, cdh, cea, ceb)

The TRS R consists of the following rules:

new_ltEs23(zwu73, zwu74, app(ty_Maybe, dgc)) → new_ltEs9(zwu73, zwu74, dgc)
new_esEs33(zwu4000, zwu6000, ty_Integer) → new_esEs25(zwu4000, zwu6000)
new_esEs31(zwu136, zwu139, app(ty_Ratio, dfh)) → new_esEs24(zwu136, zwu139, dfh)
new_ltEs10(zwu73, zwu74) → new_fsEs(new_compare12(zwu73, zwu74))
new_esEs32(zwu137, zwu140, app(ty_Ratio, dga)) → new_esEs24(zwu137, zwu140, dga)
new_compare112(zwu165, zwu166, True, eec) → LT
new_ltEs23(zwu73, zwu74, app(app(ty_Either, bdc), bcb)) → new_ltEs18(zwu73, zwu74, bdc, bcb)
new_lt23(zwu137, zwu140, ty_@0) → new_lt12(zwu137, zwu140)
new_esEs18(Char(zwu4000), Char(zwu6000)) → new_primEqNat0(zwu4000, zwu6000)
new_lt22(zwu136, zwu139, ty_@0) → new_lt12(zwu136, zwu139)
new_ltEs18(Left(zwu730), Left(zwu740), app(ty_Maybe, bca), bcb) → new_ltEs9(zwu730, zwu740, bca)
new_esEs5(zwu400, zwu600, ty_Double) → new_esEs19(zwu400, zwu600)
new_esEs22(Left(zwu4000), Left(zwu6000), ty_Int, eff) → new_esEs12(zwu4000, zwu6000)
new_esEs28(zwu730, zwu740, ty_Double) → new_esEs19(zwu730, zwu740)
new_esEs9(zwu401, zwu601, ty_@0) → new_esEs20(zwu401, zwu601)
new_esEs22(Left(zwu4000), Left(zwu6000), app(app(app(ty_@3, efc), efd), efe), eff) → new_esEs13(zwu4000, zwu6000, efc, efd, efe)
new_esEs28(zwu730, zwu740, app(ty_[], fc)) → new_esEs15(zwu730, zwu740, fc)
new_esEs27(zwu149, zwu151, app(app(ty_@2, cbf), cbg)) → new_esEs17(zwu149, zwu151, cbf, cbg)
new_ltEs14(zwu73, zwu74) → new_fsEs(new_compare15(zwu73, zwu74))
new_ltEs18(Left(zwu730), Left(zwu740), ty_@0, bcb) → new_ltEs12(zwu730, zwu740)
new_compare110(zwu179, zwu180, True, edh, eea) → LT
new_ltEs9(Just(zwu730), Just(zwu740), ty_Ordering) → new_ltEs5(zwu730, zwu740)
new_esEs8(zwu400, zwu600, ty_Integer) → new_esEs25(zwu400, zwu600)
new_lt20(zwu730, zwu740, ty_Char) → new_lt11(zwu730, zwu740)
new_esEs22(Right(zwu4000), Right(zwu6000), egf, app(ty_[], ehc)) → new_esEs15(zwu4000, zwu6000, ehc)
new_compare7(zwu400, zwu600, app(app(app(ty_@3, gd), ge), gf)) → new_compare5(zwu400, zwu600, gd, ge, gf)
new_esEs40(zwu4002, zwu6002, app(app(ty_Either, fha), fhb)) → new_esEs22(zwu4002, zwu6002, fha, fhb)
new_lt20(zwu730, zwu740, ty_Float) → new_lt14(zwu730, zwu740)
new_lt19(zwu731, zwu741, app(app(ty_Either, ee), ef)) → new_lt18(zwu731, zwu741, ee, ef)
new_esEs33(zwu4000, zwu6000, app(app(ty_@2, dhd), dhe)) → new_esEs17(zwu4000, zwu6000, dhd, dhe)
new_ltEs5(EQ, GT) → True
new_esEs4(zwu400, zwu600, app(app(app(ty_@3, faa), fab), fac)) → new_esEs13(zwu400, zwu600, faa, fab, fac)
new_ltEs9(Nothing, Just(zwu740), dgc) → True
new_esEs11(zwu400, zwu600, ty_Ordering) → new_esEs21(zwu400, zwu600)
new_esEs40(zwu4002, zwu6002, app(ty_[], fgf)) → new_esEs15(zwu4002, zwu6002, fgf)
new_esEs14(Just(zwu4000), Just(zwu6000), app(ty_Ratio, fde)) → new_esEs24(zwu4000, zwu6000, fde)
new_esEs39(zwu4001, zwu6001, app(app(ty_Either, ffg), ffh)) → new_esEs22(zwu4001, zwu6001, ffg, ffh)
new_esEs10(zwu400, zwu600, ty_Float) → new_esEs23(zwu400, zwu600)
new_ltEs6(True, False) → False
new_ltEs23(zwu73, zwu74, ty_Int) → new_ltEs15(zwu73, zwu74)
new_primMulNat0(Zero, Zero) → Zero
new_compare9(True, False) → GT
new_esEs6(zwu401, zwu601, app(app(ty_@2, daa), dab)) → new_esEs17(zwu401, zwu601, daa, dab)
new_esEs32(zwu137, zwu140, app(app(ty_Either, cad), cae)) → new_esEs22(zwu137, zwu140, cad, cae)
new_compare8(LT, GT) → LT
new_esEs32(zwu137, zwu140, ty_Int) → new_esEs12(zwu137, zwu140)
new_esEs22(Left(zwu4000), Left(zwu6000), app(ty_[], efh), eff) → new_esEs15(zwu4000, zwu6000, efh)
new_ltEs24(zwu118, zwu119, app(ty_Ratio, efb)) → new_ltEs7(zwu118, zwu119, efb)
new_ltEs18(Right(zwu730), Right(zwu740), bdc, app(ty_Ratio, dfe)) → new_ltEs7(zwu730, zwu740, dfe)
new_compare18(Left(zwu400), Right(zwu600), cdd, cde) → LT
new_lt21(zwu730, zwu740, ty_Ordering) → new_lt6(zwu730, zwu740)
new_ltEs15(zwu73, zwu74) → new_fsEs(new_compare16(zwu73, zwu74))
new_esEs27(zwu149, zwu151, app(ty_[], cbe)) → new_esEs15(zwu149, zwu151, cbe)
new_esEs28(zwu730, zwu740, ty_Bool) → new_esEs16(zwu730, zwu740)
new_esEs5(zwu400, zwu600, ty_Bool) → new_esEs16(zwu400, zwu600)
new_esEs28(zwu730, zwu740, app(ty_Maybe, eg)) → new_esEs14(zwu730, zwu740, eg)
new_esEs22(Left(zwu4000), Left(zwu6000), ty_@0, eff) → new_esEs20(zwu4000, zwu6000)
new_esEs31(zwu136, zwu139, ty_Bool) → new_esEs16(zwu136, zwu139)
new_esEs11(zwu400, zwu600, ty_Integer) → new_esEs25(zwu400, zwu600)
new_esEs4(zwu400, zwu600, app(ty_[], fae)) → new_esEs15(zwu400, zwu600, fae)
new_esEs29(zwu731, zwu741, ty_@0) → new_esEs20(zwu731, zwu741)
new_esEs35(zwu4000, zwu6000, app(ty_Maybe, fbb)) → new_esEs14(zwu4000, zwu6000, fbb)
new_esEs38(zwu4000, zwu6000, ty_Integer) → new_esEs25(zwu4000, zwu6000)
new_lt19(zwu731, zwu741, ty_Ordering) → new_lt6(zwu731, zwu741)
new_esEs22(Left(zwu4000), Left(zwu6000), app(ty_Maybe, efg), eff) → new_esEs14(zwu4000, zwu6000, efg)
new_lt22(zwu136, zwu139, app(app(ty_@2, bfg), bfh)) → new_lt17(zwu136, zwu139, bfg, bfh)
new_ltEs24(zwu118, zwu119, ty_Double) → new_ltEs8(zwu118, zwu119)
new_ltEs18(Left(zwu730), Left(zwu740), app(app(app(ty_@3, bcc), bcd), bce), bcb) → new_ltEs13(zwu730, zwu740, bcc, bcd, bce)
new_esEs11(zwu400, zwu600, app(ty_Ratio, edf)) → new_esEs24(zwu400, zwu600, edf)
new_esEs31(zwu136, zwu139, app(ty_Maybe, beh)) → new_esEs14(zwu136, zwu139, beh)
new_lt21(zwu730, zwu740, app(ty_[], bbd)) → new_lt16(zwu730, zwu740, bbd)
new_ltEs4(zwu150, zwu152, ty_@0) → new_ltEs12(zwu150, zwu152)
new_esEs14(Just(zwu4000), Just(zwu6000), app(app(ty_@2, fda), fdb)) → new_esEs17(zwu4000, zwu6000, fda, fdb)
new_compare7(zwu400, zwu600, ty_Double) → new_compare11(zwu400, zwu600)
new_esEs10(zwu400, zwu600, ty_Int) → new_esEs12(zwu400, zwu600)
new_ltEs24(zwu118, zwu119, app(app(ty_@2, cff), cfg)) → new_ltEs17(zwu118, zwu119, cff, cfg)
new_lt21(zwu730, zwu740, app(ty_Ratio, dff)) → new_lt8(zwu730, zwu740, dff)
new_lt23(zwu137, zwu140, app(ty_Ratio, dga)) → new_lt8(zwu137, zwu140, dga)
new_esEs4(zwu400, zwu600, ty_@0) → new_esEs20(zwu400, zwu600)
new_ltEs24(zwu118, zwu119, ty_Float) → new_ltEs14(zwu118, zwu119)
new_ltEs20(zwu111, zwu112, app(app(ty_@2, ced), cee)) → new_ltEs17(zwu111, zwu112, ced, cee)
new_esEs35(zwu4000, zwu6000, app(app(app(ty_@3, fag), fah), fba)) → new_esEs13(zwu4000, zwu6000, fag, fah, fba)
new_ltEs9(Just(zwu730), Just(zwu740), ty_Int) → new_ltEs15(zwu730, zwu740)
new_esEs40(zwu4002, zwu6002, app(ty_Maybe, fge)) → new_esEs14(zwu4002, zwu6002, fge)
new_ltEs18(Left(zwu730), Left(zwu740), app(app(ty_Either, bda), bdb), bcb) → new_ltEs18(zwu730, zwu740, bda, bdb)
new_compare0(:(zwu400, zwu401), :(zwu600, zwu601), gb) → new_primCompAux0(zwu400, zwu600, new_compare0(zwu401, zwu601, gb), gb)
new_lt22(zwu136, zwu139, app(ty_Ratio, dfh)) → new_lt8(zwu136, zwu139, dfh)
new_esEs35(zwu4000, zwu6000, app(app(ty_@2, fbd), fbe)) → new_esEs17(zwu4000, zwu6000, fbd, fbe)
new_ltEs5(EQ, LT) → False
new_esEs7(zwu402, zwu602, app(ty_[], dbb)) → new_esEs15(zwu402, zwu602, dbb)
new_esEs14(Just(zwu4000), Just(zwu6000), ty_Int) → new_esEs12(zwu4000, zwu6000)
new_esEs10(zwu400, zwu600, app(ty_[], ebg)) → new_esEs15(zwu400, zwu600, ebg)
new_lt23(zwu137, zwu140, ty_Float) → new_lt14(zwu137, zwu140)
new_ltEs18(Right(zwu730), Left(zwu740), bdc, bcb) → False
new_esEs9(zwu401, zwu601, app(ty_[], dea)) → new_esEs15(zwu401, zwu601, dea)
new_esEs36(zwu4000, zwu6000, ty_Integer) → new_esEs25(zwu4000, zwu6000)
new_esEs38(zwu4000, zwu6000, ty_Bool) → new_esEs16(zwu4000, zwu6000)
new_ltEs21(zwu731, zwu741, app(app(ty_@2, bac), bad)) → new_ltEs17(zwu731, zwu741, bac, bad)
new_esEs21(LT, LT) → True
new_esEs8(zwu400, zwu600, app(ty_[], dcg)) → new_esEs15(zwu400, zwu600, dcg)
new_esEs27(zwu149, zwu151, app(ty_Ratio, dca)) → new_esEs24(zwu149, zwu151, dca)
new_esEs35(zwu4000, zwu6000, ty_Float) → new_esEs23(zwu4000, zwu6000)
new_esEs29(zwu731, zwu741, app(app(app(ty_@3, dg), dh), ea)) → new_esEs13(zwu731, zwu741, dg, dh, ea)
new_esEs9(zwu401, zwu601, app(ty_Maybe, ddh)) → new_esEs14(zwu401, zwu601, ddh)
new_esEs40(zwu4002, zwu6002, ty_Int) → new_esEs12(zwu4002, zwu6002)
new_esEs27(zwu149, zwu151, app(app(ty_Either, cbh), cca)) → new_esEs22(zwu149, zwu151, cbh, cca)
new_ltEs4(zwu150, zwu152, app(app(ty_Either, cdb), cdc)) → new_ltEs18(zwu150, zwu152, cdb, cdc)
new_esEs21(GT, GT) → True
new_ltEs22(zwu138, zwu141, ty_Float) → new_ltEs14(zwu138, zwu141)
new_esEs7(zwu402, zwu602, ty_Float) → new_esEs23(zwu402, zwu602)
new_ltEs20(zwu111, zwu112, app(ty_Ratio, dfc)) → new_ltEs7(zwu111, zwu112, dfc)
new_pePe(False, zwu260) → zwu260
new_esEs22(Right(zwu4000), Right(zwu6000), egf, ty_Integer) → new_esEs25(zwu4000, zwu6000)
new_esEs33(zwu4000, zwu6000, ty_Double) → new_esEs19(zwu4000, zwu6000)
new_esEs32(zwu137, zwu140, ty_Float) → new_esEs23(zwu137, zwu140)
new_esEs20(@0, @0) → True
new_esEs9(zwu401, zwu601, app(app(ty_@2, deb), dec)) → new_esEs17(zwu401, zwu601, deb, dec)
new_esEs29(zwu731, zwu741, app(ty_Maybe, de)) → new_esEs14(zwu731, zwu741, de)
new_esEs32(zwu137, zwu140, app(app(app(ty_@3, bhf), bhg), bhh)) → new_esEs13(zwu137, zwu140, bhf, bhg, bhh)
new_esEs27(zwu149, zwu151, app(app(app(ty_@3, cbb), cbc), cbd)) → new_esEs13(zwu149, zwu151, cbb, cbc, cbd)
new_esEs15(:(zwu4000, zwu4001), :(zwu6000, zwu6001), fae) → new_asAs(new_esEs35(zwu4000, zwu6000, fae), new_esEs15(zwu4001, zwu6001, fae))
new_esEs29(zwu731, zwu741, ty_Char) → new_esEs18(zwu731, zwu741)
new_ltEs21(zwu731, zwu741, ty_Double) → new_ltEs8(zwu731, zwu741)
new_esEs9(zwu401, zwu601, app(app(ty_Either, ded), dee)) → new_esEs22(zwu401, zwu601, ded, dee)
new_esEs14(Just(zwu4000), Just(zwu6000), app(app(ty_Either, fdc), fdd)) → new_esEs22(zwu4000, zwu6000, fdc, fdd)
new_esEs7(zwu402, zwu602, ty_Int) → new_esEs12(zwu402, zwu602)
new_lt19(zwu731, zwu741, app(ty_[], eb)) → new_lt16(zwu731, zwu741, eb)
new_lt5(zwu149, zwu151, app(ty_[], cbe)) → new_lt16(zwu149, zwu151, cbe)
new_esEs14(Just(zwu4000), Just(zwu6000), ty_@0) → new_esEs20(zwu4000, zwu6000)
new_ltEs23(zwu73, zwu74, ty_Char) → new_ltEs11(zwu73, zwu74)
new_esEs29(zwu731, zwu741, app(app(ty_@2, ec), ed)) → new_esEs17(zwu731, zwu741, ec, ed)
new_esEs38(zwu4000, zwu6000, app(app(app(ty_@3, fdf), fdg), fdh)) → new_esEs13(zwu4000, zwu6000, fdf, fdg, fdh)
new_esEs40(zwu4002, zwu6002, app(app(ty_@2, fgg), fgh)) → new_esEs17(zwu4002, zwu6002, fgg, fgh)
new_compare14(@0, @0) → EQ
new_lt20(zwu730, zwu740, app(app(ty_@2, fd), ff)) → new_lt17(zwu730, zwu740, fd, ff)
new_esEs31(zwu136, zwu139, app(app(ty_Either, bga), bgb)) → new_esEs22(zwu136, zwu139, bga, bgb)
new_lt20(zwu730, zwu740, app(app(app(ty_@3, eh), fa), fb)) → new_lt13(zwu730, zwu740, eh, fa, fb)
new_esEs5(zwu400, zwu600, ty_@0) → new_esEs20(zwu400, zwu600)
new_ltEs23(zwu73, zwu74, ty_Float) → new_ltEs14(zwu73, zwu74)
new_esEs26(EQ) → False
new_esEs28(zwu730, zwu740, ty_@0) → new_esEs20(zwu730, zwu740)
new_esEs30(zwu730, zwu740, ty_Ordering) → new_esEs21(zwu730, zwu740)
new_esEs11(zwu400, zwu600, app(ty_[], eda)) → new_esEs15(zwu400, zwu600, eda)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_lt5(zwu149, zwu151, ty_Int) → new_lt15(zwu149, zwu151)
new_esEs35(zwu4000, zwu6000, ty_Bool) → new_esEs16(zwu4000, zwu6000)
new_ltEs22(zwu138, zwu141, app(app(ty_Either, bhc), bhd)) → new_ltEs18(zwu138, zwu141, bhc, bhd)
new_esEs35(zwu4000, zwu6000, app(app(ty_Either, fbf), fbg)) → new_esEs22(zwu4000, zwu6000, fbf, fbg)
new_esEs31(zwu136, zwu139, ty_Integer) → new_esEs25(zwu136, zwu139)
new_esEs21(EQ, GT) → False
new_esEs21(GT, EQ) → False
new_esEs28(zwu730, zwu740, app(app(ty_Either, fg), fh)) → new_esEs22(zwu730, zwu740, fg, fh)
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_compare113(zwu248, zwu249, zwu250, zwu251, True, eed, eee) → LT
new_ltEs18(Right(zwu730), Right(zwu740), bdc, app(app(ty_@2, bea), beb)) → new_ltEs17(zwu730, zwu740, bea, beb)
new_esEs11(zwu400, zwu600, ty_Char) → new_esEs18(zwu400, zwu600)
new_esEs22(Left(zwu4000), Left(zwu6000), app(ty_Ratio, ege), eff) → new_esEs24(zwu4000, zwu6000, ege)
new_lt6(zwu40, zwu60) → new_esEs26(new_compare8(zwu40, zwu60))
new_esEs4(zwu400, zwu600, app(ty_Ratio, faf)) → new_esEs24(zwu400, zwu600, faf)
new_lt20(zwu730, zwu740, ty_Ordering) → new_lt6(zwu730, zwu740)
new_ltEs19(zwu732, zwu742, ty_Bool) → new_ltEs6(zwu732, zwu742)
new_esEs22(Right(zwu4000), Right(zwu6000), egf, ty_Int) → new_esEs12(zwu4000, zwu6000)
new_esEs5(zwu400, zwu600, app(ty_Ratio, chc)) → new_esEs24(zwu400, zwu600, chc)
new_ltEs24(zwu118, zwu119, ty_Ordering) → new_ltEs5(zwu118, zwu119)
new_esEs40(zwu4002, zwu6002, app(app(app(ty_@3, fgb), fgc), fgd)) → new_esEs13(zwu4002, zwu6002, fgb, fgc, fgd)
new_ltEs22(zwu138, zwu141, ty_Ordering) → new_ltEs5(zwu138, zwu141)
new_lt22(zwu136, zwu139, app(ty_Maybe, beh)) → new_lt4(zwu136, zwu139, beh)
new_ltEs18(Right(zwu730), Right(zwu740), bdc, app(app(ty_Either, bec), bed)) → new_ltEs18(zwu730, zwu740, bec, bed)
new_ltEs9(Just(zwu730), Just(zwu740), ty_Char) → new_ltEs11(zwu730, zwu740)
new_lt21(zwu730, zwu740, app(app(ty_@2, bbe), bbf)) → new_lt17(zwu730, zwu740, bbe, bbf)
new_ltEs21(zwu731, zwu741, app(ty_[], bab)) → new_ltEs16(zwu731, zwu741, bab)
new_esEs9(zwu401, zwu601, ty_Float) → new_esEs23(zwu401, zwu601)
new_esEs31(zwu136, zwu139, app(app(ty_@2, bfg), bfh)) → new_esEs17(zwu136, zwu139, bfg, bfh)
new_ltEs9(Just(zwu730), Just(zwu740), ty_Double) → new_ltEs8(zwu730, zwu740)
new_lt5(zwu149, zwu151, app(ty_Ratio, dca)) → new_lt8(zwu149, zwu151, dca)
new_esEs8(zwu400, zwu600, app(app(ty_Either, ddb), ddc)) → new_esEs22(zwu400, zwu600, ddb, ddc)
new_esEs40(zwu4002, zwu6002, ty_Integer) → new_esEs25(zwu4002, zwu6002)
new_ltEs20(zwu111, zwu112, app(ty_Maybe, cdf)) → new_ltEs9(zwu111, zwu112, cdf)
new_esEs34(zwu4001, zwu6001, app(app(ty_Either, eah), eba)) → new_esEs22(zwu4001, zwu6001, eah, eba)
new_ltEs18(Right(zwu730), Right(zwu740), bdc, ty_Bool) → new_ltEs6(zwu730, zwu740)
new_compare7(zwu400, zwu600, app(ty_[], gg)) → new_compare0(zwu400, zwu600, gg)
new_esEs39(zwu4001, zwu6001, ty_@0) → new_esEs20(zwu4001, zwu6001)
new_pePe(True, zwu260) → True
new_compare0([], [], gb) → EQ
new_esEs39(zwu4001, zwu6001, app(ty_[], ffd)) → new_esEs15(zwu4001, zwu6001, ffd)
new_primEqNat0(Zero, Zero) → True
new_esEs22(Right(zwu4000), Right(zwu6000), egf, app(app(app(ty_@3, egg), egh), eha)) → new_esEs13(zwu4000, zwu6000, egg, egh, eha)
new_ltEs24(zwu118, zwu119, ty_@0) → new_ltEs12(zwu118, zwu119)
new_esEs29(zwu731, zwu741, ty_Integer) → new_esEs25(zwu731, zwu741)
new_lt20(zwu730, zwu740, ty_Int) → new_lt15(zwu730, zwu740)
new_esEs6(zwu401, zwu601, ty_Ordering) → new_esEs21(zwu401, zwu601)
new_ltEs21(zwu731, zwu741, app(app(app(ty_@3, hg), hh), baa)) → new_ltEs13(zwu731, zwu741, hg, hh, baa)
new_esEs27(zwu149, zwu151, ty_Float) → new_esEs23(zwu149, zwu151)
new_esEs11(zwu400, zwu600, ty_Float) → new_esEs23(zwu400, zwu600)
new_compare6(Just(zwu400), Just(zwu600), hd) → new_compare29(zwu400, zwu600, new_esEs4(zwu400, zwu600, hd), hd)
new_lt20(zwu730, zwu740, app(ty_Ratio, deg)) → new_lt8(zwu730, zwu740, deg)
new_ltEs21(zwu731, zwu741, app(ty_Maybe, hf)) → new_ltEs9(zwu731, zwu741, hf)
new_lt20(zwu730, zwu740, ty_Bool) → new_lt7(zwu730, zwu740)
new_ltEs22(zwu138, zwu141, ty_Integer) → new_ltEs10(zwu138, zwu141)
new_ltEs4(zwu150, zwu152, ty_Bool) → new_ltEs6(zwu150, zwu152)
new_esEs7(zwu402, zwu602, app(ty_Ratio, dbg)) → new_esEs24(zwu402, zwu602, dbg)
new_lt21(zwu730, zwu740, ty_Bool) → new_lt7(zwu730, zwu740)
new_ltEs23(zwu73, zwu74, app(ty_Ratio, edg)) → new_ltEs7(zwu73, zwu74, edg)
new_esEs6(zwu401, zwu601, ty_Char) → new_esEs18(zwu401, zwu601)
new_compare110(zwu179, zwu180, False, edh, eea) → GT
new_esEs31(zwu136, zwu139, ty_Double) → new_esEs19(zwu136, zwu139)
new_lt22(zwu136, zwu139, ty_Ordering) → new_lt6(zwu136, zwu139)
new_lt5(zwu149, zwu151, app(app(app(ty_@3, cbb), cbc), cbd)) → new_lt13(zwu149, zwu151, cbb, cbc, cbd)
new_esEs38(zwu4000, zwu6000, ty_Char) → new_esEs18(zwu4000, zwu6000)
new_sr(zwu400, zwu601) → new_primMulInt(zwu400, zwu601)
new_esEs29(zwu731, zwu741, ty_Float) → new_esEs23(zwu731, zwu741)
new_ltEs19(zwu732, zwu742, ty_@0) → new_ltEs12(zwu732, zwu742)
new_esEs34(zwu4001, zwu6001, ty_Double) → new_esEs19(zwu4001, zwu6001)
new_esEs30(zwu730, zwu740, app(ty_Ratio, dff)) → new_esEs24(zwu730, zwu740, dff)
new_esEs14(Just(zwu4000), Just(zwu6000), app(ty_Maybe, fcg)) → new_esEs14(zwu4000, zwu6000, fcg)
new_esEs33(zwu4000, zwu6000, app(ty_[], dhc)) → new_esEs15(zwu4000, zwu6000, dhc)
new_ltEs21(zwu731, zwu741, ty_Ordering) → new_ltEs5(zwu731, zwu741)
new_esEs35(zwu4000, zwu6000, ty_Ordering) → new_esEs21(zwu4000, zwu6000)
new_esEs27(zwu149, zwu151, ty_@0) → new_esEs20(zwu149, zwu151)
new_lt23(zwu137, zwu140, ty_Double) → new_lt9(zwu137, zwu140)
new_esEs31(zwu136, zwu139, app(ty_[], bff)) → new_esEs15(zwu136, zwu139, bff)
new_compare7(zwu400, zwu600, app(ty_Maybe, gc)) → new_compare6(zwu400, zwu600, gc)
new_esEs5(zwu400, zwu600, ty_Integer) → new_esEs25(zwu400, zwu600)
new_lt22(zwu136, zwu139, app(ty_[], bff)) → new_lt16(zwu136, zwu139, bff)
new_esEs9(zwu401, zwu601, ty_Ordering) → new_esEs21(zwu401, zwu601)
new_ltEs5(LT, LT) → True
new_esEs38(zwu4000, zwu6000, app(ty_[], feb)) → new_esEs15(zwu4000, zwu6000, feb)
new_ltEs19(zwu732, zwu742, app(ty_Maybe, cc)) → new_ltEs9(zwu732, zwu742, cc)
new_esEs8(zwu400, zwu600, ty_Char) → new_esEs18(zwu400, zwu600)
new_ltEs20(zwu111, zwu112, ty_Int) → new_ltEs15(zwu111, zwu112)
new_compare8(LT, EQ) → LT
new_ltEs18(Right(zwu730), Right(zwu740), bdc, ty_Integer) → new_ltEs10(zwu730, zwu740)
new_esEs29(zwu731, zwu741, ty_Int) → new_esEs12(zwu731, zwu741)
new_esEs14(Nothing, Just(zwu6000), fad) → False
new_esEs14(Just(zwu4000), Nothing, fad) → False
new_ltEs18(Right(zwu730), Right(zwu740), bdc, app(ty_Maybe, bdd)) → new_ltEs9(zwu730, zwu740, bdd)
new_primEqInt(Neg(Succ(zwu40000)), Neg(Succ(zwu60000))) → new_primEqNat0(zwu40000, zwu60000)
new_ltEs19(zwu732, zwu742, app(app(ty_@2, da), db)) → new_ltEs17(zwu732, zwu742, da, db)
new_esEs39(zwu4001, zwu6001, app(app(ty_@2, ffe), fff)) → new_esEs17(zwu4001, zwu6001, ffe, fff)
new_esEs22(Left(zwu4000), Left(zwu6000), ty_Ordering, eff) → new_esEs21(zwu4000, zwu6000)
new_ltEs12(zwu73, zwu74) → new_fsEs(new_compare14(zwu73, zwu74))
new_esEs5(zwu400, zwu600, ty_Float) → new_esEs23(zwu400, zwu600)
new_compare7(zwu400, zwu600, ty_Ordering) → new_compare8(zwu400, zwu600)
new_ltEs22(zwu138, zwu141, app(ty_Ratio, dgb)) → new_ltEs7(zwu138, zwu141, dgb)
new_esEs9(zwu401, zwu601, app(app(app(ty_@3, dde), ddf), ddg)) → new_esEs13(zwu401, zwu601, dde, ddf, ddg)
new_compare115(zwu189, zwu190, True, fca, fcb) → LT
new_esEs38(zwu4000, zwu6000, ty_@0) → new_esEs20(zwu4000, zwu6000)
new_esEs35(zwu4000, zwu6000, ty_Double) → new_esEs19(zwu4000, zwu6000)
new_lt19(zwu731, zwu741, ty_Bool) → new_lt7(zwu731, zwu741)
new_esEs10(zwu400, zwu600, ty_Integer) → new_esEs25(zwu400, zwu600)
new_lt19(zwu731, zwu741, ty_Integer) → new_lt10(zwu731, zwu741)
new_esEs40(zwu4002, zwu6002, app(ty_Ratio, fhc)) → new_esEs24(zwu4002, zwu6002, fhc)
new_esEs32(zwu137, zwu140, ty_Integer) → new_esEs25(zwu137, zwu140)
new_ltEs18(Right(zwu730), Right(zwu740), bdc, ty_@0) → new_ltEs12(zwu730, zwu740)
new_esEs11(zwu400, zwu600, ty_Int) → new_esEs12(zwu400, zwu600)
new_esEs30(zwu730, zwu740, ty_Integer) → new_esEs25(zwu730, zwu740)
new_compare18(Left(zwu400), Left(zwu600), cdd, cde) → new_compare27(zwu400, zwu600, new_esEs10(zwu400, zwu600, cdd), cdd, cde)
new_esEs16(False, True) → False
new_esEs16(True, False) → False
new_lt23(zwu137, zwu140, ty_Bool) → new_lt7(zwu137, zwu140)
new_primEqInt(Neg(Zero), Neg(Zero)) → True
new_esEs27(zwu149, zwu151, ty_Int) → new_esEs12(zwu149, zwu151)
new_esEs33(zwu4000, zwu6000, ty_Bool) → new_esEs16(zwu4000, zwu6000)
new_ltEs20(zwu111, zwu112, ty_@0) → new_ltEs12(zwu111, zwu112)
new_esEs39(zwu4001, zwu6001, ty_Bool) → new_esEs16(zwu4001, zwu6001)
new_lt22(zwu136, zwu139, ty_Int) → new_lt15(zwu136, zwu139)
new_esEs26(GT) → False
new_ltEs21(zwu731, zwu741, app(ty_Ratio, dfg)) → new_ltEs7(zwu731, zwu741, dfg)
new_esEs9(zwu401, zwu601, ty_Int) → new_esEs12(zwu401, zwu601)
new_primEqInt(Neg(Succ(zwu40000)), Neg(Zero)) → False
new_primEqInt(Neg(Zero), Neg(Succ(zwu60000))) → False
new_lt9(zwu40, zwu60) → new_esEs26(new_compare11(zwu40, zwu60))
new_esEs9(zwu401, zwu601, app(ty_Ratio, def)) → new_esEs24(zwu401, zwu601, def)
new_esEs34(zwu4001, zwu6001, app(ty_[], eae)) → new_esEs15(zwu4001, zwu6001, eae)
new_ltEs18(Left(zwu730), Right(zwu740), bdc, bcb) → True
new_ltEs24(zwu118, zwu119, app(ty_[], cfe)) → new_ltEs16(zwu118, zwu119, cfe)
new_compare9(False, False) → EQ
new_esEs28(zwu730, zwu740, ty_Integer) → new_esEs25(zwu730, zwu740)
new_esEs30(zwu730, zwu740, ty_Bool) → new_esEs16(zwu730, zwu740)
new_lt21(zwu730, zwu740, ty_Float) → new_lt14(zwu730, zwu740)
new_esEs14(Just(zwu4000), Just(zwu6000), app(ty_[], fch)) → new_esEs15(zwu4000, zwu6000, fch)
new_esEs33(zwu4000, zwu6000, app(app(ty_Either, dhf), dhg)) → new_esEs22(zwu4000, zwu6000, dhf, dhg)
new_esEs8(zwu400, zwu600, ty_@0) → new_esEs20(zwu400, zwu600)
new_esEs33(zwu4000, zwu6000, ty_Int) → new_esEs12(zwu4000, zwu6000)
new_lt18(zwu40, zwu60, cdd, cde) → new_esEs26(new_compare18(zwu40, zwu60, cdd, cde))
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_ltEs18(Left(zwu730), Left(zwu740), ty_Double, bcb) → new_ltEs8(zwu730, zwu740)
new_esEs29(zwu731, zwu741, ty_Bool) → new_esEs16(zwu731, zwu741)
new_esEs8(zwu400, zwu600, ty_Int) → new_esEs12(zwu400, zwu600)
new_ltEs20(zwu111, zwu112, app(app(ty_Either, cef), ceg)) → new_ltEs18(zwu111, zwu112, cef, ceg)
new_ltEs24(zwu118, zwu119, ty_Char) → new_ltEs11(zwu118, zwu119)
new_ltEs22(zwu138, zwu141, ty_Char) → new_ltEs11(zwu138, zwu141)
new_esEs35(zwu4000, zwu6000, ty_Char) → new_esEs18(zwu4000, zwu6000)
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_lt22(zwu136, zwu139, app(app(app(ty_@3, bfc), bfd), bfe)) → new_lt13(zwu136, zwu139, bfc, bfd, bfe)
new_ltEs5(EQ, EQ) → True
new_compare18(Right(zwu400), Left(zwu600), cdd, cde) → GT
new_esEs14(Just(zwu4000), Just(zwu6000), ty_Char) → new_esEs18(zwu4000, zwu6000)
new_esEs9(zwu401, zwu601, ty_Integer) → new_esEs25(zwu401, zwu601)
new_esEs38(zwu4000, zwu6000, app(app(ty_Either, fee), fef)) → new_esEs22(zwu4000, zwu6000, fee, fef)
new_esEs29(zwu731, zwu741, app(ty_Ratio, deh)) → new_esEs24(zwu731, zwu741, deh)
new_esEs34(zwu4001, zwu6001, ty_Char) → new_esEs18(zwu4001, zwu6001)
new_lt10(zwu40, zwu60) → new_esEs26(new_compare12(zwu40, zwu60))
new_primEqInt(Pos(Succ(zwu40000)), Pos(Succ(zwu60000))) → new_primEqNat0(zwu40000, zwu60000)
new_compare27(zwu111, zwu112, True, dfb, cdg) → EQ
new_compare7(zwu400, zwu600, ty_Char) → new_compare13(zwu400, zwu600)
new_ltEs20(zwu111, zwu112, ty_Float) → new_ltEs14(zwu111, zwu112)
new_esEs8(zwu400, zwu600, app(ty_Ratio, ddd)) → new_esEs24(zwu400, zwu600, ddd)
new_esEs11(zwu400, zwu600, ty_Bool) → new_esEs16(zwu400, zwu600)
new_compare8(GT, GT) → EQ
new_esEs7(zwu402, zwu602, ty_Integer) → new_esEs25(zwu402, zwu602)
new_lt21(zwu730, zwu740, ty_Integer) → new_lt10(zwu730, zwu740)
new_ltEs6(False, True) → True
new_esEs38(zwu4000, zwu6000, ty_Ordering) → new_esEs21(zwu4000, zwu6000)
new_esEs5(zwu400, zwu600, app(ty_[], cgf)) → new_esEs15(zwu400, zwu600, cgf)
new_esEs34(zwu4001, zwu6001, app(app(ty_@2, eaf), eag)) → new_esEs17(zwu4001, zwu6001, eaf, eag)
new_esEs22(Left(zwu4000), Left(zwu6000), ty_Bool, eff) → new_esEs16(zwu4000, zwu6000)
new_primEqNat0(Succ(zwu40000), Succ(zwu60000)) → new_primEqNat0(zwu40000, zwu60000)
new_esEs4(zwu400, zwu600, ty_Integer) → new_esEs25(zwu400, zwu600)
new_esEs39(zwu4001, zwu6001, ty_Double) → new_esEs19(zwu4001, zwu6001)
new_lt20(zwu730, zwu740, ty_@0) → new_lt12(zwu730, zwu740)
new_ltEs6(True, True) → True
new_lt22(zwu136, zwu139, ty_Bool) → new_lt7(zwu136, zwu139)
new_ltEs24(zwu118, zwu119, ty_Int) → new_ltEs15(zwu118, zwu119)
new_esEs22(Right(zwu4000), Right(zwu6000), egf, ty_Bool) → new_esEs16(zwu4000, zwu6000)
new_esEs22(Right(zwu4000), Right(zwu6000), egf, ty_@0) → new_esEs20(zwu4000, zwu6000)
new_lt23(zwu137, zwu140, app(app(app(ty_@3, bhf), bhg), bhh)) → new_lt13(zwu137, zwu140, bhf, bhg, bhh)
new_compare8(EQ, EQ) → EQ
new_lt21(zwu730, zwu740, ty_Int) → new_lt15(zwu730, zwu740)
new_lt21(zwu730, zwu740, ty_@0) → new_lt12(zwu730, zwu740)
new_compare6(Nothing, Nothing, hd) → EQ
new_ltEs9(Just(zwu730), Just(zwu740), app(ty_Ratio, dgd)) → new_ltEs7(zwu730, zwu740, dgd)
new_primCompAux00(zwu94, LT) → LT
new_esEs33(zwu4000, zwu6000, ty_@0) → new_esEs20(zwu4000, zwu6000)
new_esEs22(Left(zwu4000), Left(zwu6000), ty_Float, eff) → new_esEs23(zwu4000, zwu6000)
new_esEs21(EQ, EQ) → True
new_esEs11(zwu400, zwu600, app(ty_Maybe, ech)) → new_esEs14(zwu400, zwu600, ech)
new_esEs32(zwu137, zwu140, app(ty_Maybe, bhe)) → new_esEs14(zwu137, zwu140, bhe)
new_esEs22(Right(zwu4000), Right(zwu6000), egf, app(app(ty_@2, ehd), ehe)) → new_esEs17(zwu4000, zwu6000, ehd, ehe)
new_ltEs22(zwu138, zwu141, app(app(app(ty_@3, bge), bgf), bgg)) → new_ltEs13(zwu138, zwu141, bge, bgf, bgg)
new_esEs35(zwu4000, zwu6000, ty_@0) → new_esEs20(zwu4000, zwu6000)
new_ltEs18(Left(zwu730), Left(zwu740), app(app(ty_@2, bcg), bch), bcb) → new_ltEs17(zwu730, zwu740, bcg, bch)
new_esEs32(zwu137, zwu140, ty_@0) → new_esEs20(zwu137, zwu140)
new_esEs38(zwu4000, zwu6000, app(ty_Maybe, fea)) → new_esEs14(zwu4000, zwu6000, fea)
new_esEs15([], [], fae) → True
new_compare10(:%(zwu400, zwu401), :%(zwu600, zwu601), ty_Integer) → new_compare12(new_sr0(zwu400, zwu601), new_sr0(zwu600, zwu401))
new_primEqInt(Pos(Succ(zwu40000)), Pos(Zero)) → False
new_primEqInt(Pos(Zero), Pos(Succ(zwu60000))) → False
new_compare7(zwu400, zwu600, ty_Int) → new_compare16(zwu400, zwu600)
new_esEs8(zwu400, zwu600, ty_Ordering) → new_esEs21(zwu400, zwu600)
new_esEs34(zwu4001, zwu6001, ty_@0) → new_esEs20(zwu4001, zwu6001)
new_esEs5(zwu400, zwu600, ty_Char) → new_esEs18(zwu400, zwu600)
new_ltEs8(zwu73, zwu74) → new_fsEs(new_compare11(zwu73, zwu74))
new_compare7(zwu400, zwu600, ty_@0) → new_compare14(zwu400, zwu600)
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_ltEs4(zwu150, zwu152, ty_Double) → new_ltEs8(zwu150, zwu152)
new_ltEs5(GT, LT) → False
new_compare25(zwu136, zwu137, zwu138, zwu139, zwu140, zwu141, True, bgc, bfa, bfb) → EQ
new_primCmpNat0(Zero, Zero) → EQ
new_lt22(zwu136, zwu139, ty_Char) → new_lt11(zwu136, zwu139)
new_esEs19(Double(zwu4000, zwu4001), Double(zwu6000, zwu6001)) → new_esEs12(new_sr(zwu4000, zwu6000), new_sr(zwu4001, zwu6001))
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_ltEs9(Just(zwu730), Just(zwu740), app(ty_Maybe, h)) → new_ltEs9(zwu730, zwu740, h)
new_ltEs20(zwu111, zwu112, ty_Ordering) → new_ltEs5(zwu111, zwu112)
new_esEs27(zwu149, zwu151, ty_Ordering) → new_esEs21(zwu149, zwu151)
new_esEs30(zwu730, zwu740, ty_@0) → new_esEs20(zwu730, zwu740)
new_esEs6(zwu401, zwu601, ty_@0) → new_esEs20(zwu401, zwu601)
new_esEs10(zwu400, zwu600, app(app(app(ty_@3, ebc), ebd), ebe)) → new_esEs13(zwu400, zwu600, ebc, ebd, ebe)
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_ltEs20(zwu111, zwu112, ty_Integer) → new_ltEs10(zwu111, zwu112)
new_esEs4(zwu400, zwu600, ty_Float) → new_esEs23(zwu400, zwu600)
new_esEs6(zwu401, zwu601, ty_Int) → new_esEs12(zwu401, zwu601)
new_ltEs9(Just(zwu730), Just(zwu740), app(ty_[], bd)) → new_ltEs16(zwu730, zwu740, bd)
new_lt16(zwu40, zwu60, gb) → new_esEs26(new_compare0(zwu40, zwu60, gb))
new_lt23(zwu137, zwu140, ty_Integer) → new_lt10(zwu137, zwu140)
new_sr0(Integer(zwu4000), Integer(zwu6010)) → Integer(new_primMulInt(zwu4000, zwu6010))
new_esEs40(zwu4002, zwu6002, ty_Char) → new_esEs18(zwu4002, zwu6002)
new_compare26(zwu149, zwu150, zwu151, zwu152, False, ccb, cba) → new_compare19(zwu149, zwu150, zwu151, zwu152, new_lt5(zwu149, zwu151, ccb), new_asAs(new_esEs27(zwu149, zwu151, ccb), new_ltEs4(zwu150, zwu152, cba)), ccb, cba)
new_compare28(zwu118, zwu119, True, ceh, efa) → EQ
new_esEs28(zwu730, zwu740, app(ty_Ratio, deg)) → new_esEs24(zwu730, zwu740, deg)
new_esEs10(zwu400, zwu600, ty_Char) → new_esEs18(zwu400, zwu600)
new_primEqInt(Pos(Succ(zwu40000)), Neg(zwu6000)) → False
new_primEqInt(Neg(Succ(zwu40000)), Pos(zwu6000)) → False
new_esEs7(zwu402, zwu602, app(app(ty_Either, dbe), dbf)) → new_esEs22(zwu402, zwu602, dbe, dbf)
new_esEs5(zwu400, zwu600, ty_Int) → new_esEs12(zwu400, zwu600)
new_lt13(zwu40, zwu60, bee, bef, beg) → new_esEs26(new_compare5(zwu40, zwu60, bee, bef, beg))
new_esEs6(zwu401, zwu601, ty_Bool) → new_esEs16(zwu401, zwu601)
new_esEs24(:%(zwu4000, zwu4001), :%(zwu6000, zwu6001), faf) → new_asAs(new_esEs36(zwu4000, zwu6000, faf), new_esEs37(zwu4001, zwu6001, faf))
new_lt23(zwu137, zwu140, app(ty_Maybe, bhe)) → new_lt4(zwu137, zwu140, bhe)
new_ltEs11(zwu73, zwu74) → new_fsEs(new_compare13(zwu73, zwu74))
new_ltEs24(zwu118, zwu119, ty_Integer) → new_ltEs10(zwu118, zwu119)
new_compare7(zwu400, zwu600, ty_Float) → new_compare15(zwu400, zwu600)
new_lt23(zwu137, zwu140, ty_Ordering) → new_lt6(zwu137, zwu140)
new_lt11(zwu40, zwu60) → new_esEs26(new_compare13(zwu40, zwu60))
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primEqInt(Pos(Zero), Neg(Succ(zwu60000))) → False
new_primEqInt(Neg(Zero), Pos(Succ(zwu60000))) → False
new_ltEs9(Just(zwu730), Nothing, dgc) → False
new_primCompAux00(zwu94, EQ) → zwu94
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_esEs8(zwu400, zwu600, ty_Float) → new_esEs23(zwu400, zwu600)
new_esEs22(Left(zwu4000), Left(zwu6000), ty_Integer, eff) → new_esEs25(zwu4000, zwu6000)
new_compare15(Float(zwu400, zwu401), Float(zwu600, zwu601)) → new_compare16(new_sr(zwu400, zwu600), new_sr(zwu401, zwu601))
new_ltEs18(Left(zwu730), Left(zwu740), ty_Integer, bcb) → new_ltEs10(zwu730, zwu740)
new_esEs38(zwu4000, zwu6000, app(app(ty_@2, fec), fed)) → new_esEs17(zwu4000, zwu6000, fec, fed)
new_esEs10(zwu400, zwu600, ty_Double) → new_esEs19(zwu400, zwu600)
new_esEs31(zwu136, zwu139, ty_Int) → new_esEs12(zwu136, zwu139)
new_ltEs17(@2(zwu730, zwu731), @2(zwu740, zwu741), he, bah) → new_pePe(new_lt21(zwu730, zwu740, he), new_asAs(new_esEs30(zwu730, zwu740, he), new_ltEs21(zwu731, zwu741, bah)))
new_lt15(zwu40, zwu60) → new_esEs26(new_compare16(zwu40, zwu60))
new_esEs7(zwu402, zwu602, ty_Double) → new_esEs19(zwu402, zwu602)
new_ltEs19(zwu732, zwu742, app(app(app(ty_@3, cd), ce), cf)) → new_ltEs13(zwu732, zwu742, cd, ce, cf)
new_esEs38(zwu4000, zwu6000, ty_Double) → new_esEs19(zwu4000, zwu6000)
new_esEs5(zwu400, zwu600, ty_Ordering) → new_esEs21(zwu400, zwu600)
new_esEs6(zwu401, zwu601, ty_Float) → new_esEs23(zwu401, zwu601)
new_ltEs23(zwu73, zwu74, ty_Double) → new_ltEs8(zwu73, zwu74)
new_compare29(zwu73, zwu74, False, eeb) → new_compare112(zwu73, zwu74, new_ltEs23(zwu73, zwu74, eeb), eeb)
new_compare7(zwu400, zwu600, app(app(ty_Either, hb), hc)) → new_compare18(zwu400, zwu600, hb, hc)
new_esEs11(zwu400, zwu600, ty_@0) → new_esEs20(zwu400, zwu600)
new_esEs7(zwu402, zwu602, app(app(ty_@2, dbc), dbd)) → new_esEs17(zwu402, zwu602, dbc, dbd)
new_ltEs9(Just(zwu730), Just(zwu740), ty_Bool) → new_ltEs6(zwu730, zwu740)
new_esEs4(zwu400, zwu600, ty_Int) → new_esEs12(zwu400, zwu600)
new_not(False) → True
new_esEs28(zwu730, zwu740, ty_Ordering) → new_esEs21(zwu730, zwu740)
new_ltEs18(Right(zwu730), Right(zwu740), bdc, ty_Float) → new_ltEs14(zwu730, zwu740)
new_lt21(zwu730, zwu740, ty_Double) → new_lt9(zwu730, zwu740)
new_esEs8(zwu400, zwu600, app(ty_Maybe, dcf)) → new_esEs14(zwu400, zwu600, dcf)
new_esEs22(Right(zwu4000), Right(zwu6000), egf, app(ty_Ratio, ehh)) → new_esEs24(zwu4000, zwu6000, ehh)
new_esEs40(zwu4002, zwu6002, ty_Ordering) → new_esEs21(zwu4002, zwu6002)
new_lt19(zwu731, zwu741, ty_Int) → new_lt15(zwu731, zwu741)
new_lt5(zwu149, zwu151, ty_Integer) → new_lt10(zwu149, zwu151)
new_ltEs9(Nothing, Nothing, dgc) → True
new_esEs4(zwu400, zwu600, app(app(ty_@2, dge), dgf)) → new_esEs17(zwu400, zwu600, dge, dgf)
new_esEs14(Just(zwu4000), Just(zwu6000), ty_Double) → new_esEs19(zwu4000, zwu6000)
new_esEs28(zwu730, zwu740, app(app(app(ty_@3, eh), fa), fb)) → new_esEs13(zwu730, zwu740, eh, fa, fb)
new_ltEs20(zwu111, zwu112, ty_Char) → new_ltEs11(zwu111, zwu112)
new_esEs8(zwu400, zwu600, app(app(app(ty_@3, dcc), dcd), dce)) → new_esEs13(zwu400, zwu600, dcc, dcd, dce)
new_compare17(@2(zwu400, zwu401), @2(zwu600, zwu601), caf, cag) → new_compare26(zwu400, zwu401, zwu600, zwu601, new_asAs(new_esEs8(zwu400, zwu600, caf), new_esEs9(zwu401, zwu601, cag)), caf, cag)
new_lt4(zwu40, zwu60, hd) → new_esEs26(new_compare6(zwu40, zwu60, hd))
new_esEs35(zwu4000, zwu6000, ty_Int) → new_esEs12(zwu4000, zwu6000)
new_lt5(zwu149, zwu151, ty_Bool) → new_lt7(zwu149, zwu151)
new_esEs40(zwu4002, zwu6002, ty_@0) → new_esEs20(zwu4002, zwu6002)
new_ltEs4(zwu150, zwu152, app(app(app(ty_@3, ccd), cce), ccf)) → new_ltEs13(zwu150, zwu152, ccd, cce, ccf)
new_esEs22(Right(zwu4000), Right(zwu6000), egf, ty_Float) → new_esEs23(zwu4000, zwu6000)
new_esEs22(Left(zwu4000), Left(zwu6000), app(app(ty_Either, egc), egd), eff) → new_esEs22(zwu4000, zwu6000, egc, egd)
new_ltEs18(Left(zwu730), Left(zwu740), ty_Ordering, bcb) → new_ltEs5(zwu730, zwu740)
new_esEs30(zwu730, zwu740, app(app(ty_@2, bbe), bbf)) → new_esEs17(zwu730, zwu740, bbe, bbf)
new_compare0(:(zwu400, zwu401), [], gb) → GT
new_esEs32(zwu137, zwu140, app(ty_[], caa)) → new_esEs15(zwu137, zwu140, caa)
new_compare12(Integer(zwu400), Integer(zwu600)) → new_primCmpInt(zwu400, zwu600)
new_lt20(zwu730, zwu740, ty_Double) → new_lt9(zwu730, zwu740)
new_esEs35(zwu4000, zwu6000, app(ty_Ratio, fbh)) → new_esEs24(zwu4000, zwu6000, fbh)
new_lt19(zwu731, zwu741, ty_Float) → new_lt14(zwu731, zwu741)
new_esEs7(zwu402, zwu602, app(app(app(ty_@3, daf), dag), dah)) → new_esEs13(zwu402, zwu602, daf, dag, dah)
new_lt22(zwu136, zwu139, ty_Float) → new_lt14(zwu136, zwu139)
new_ltEs18(Right(zwu730), Right(zwu740), bdc, ty_Int) → new_ltEs15(zwu730, zwu740)
new_ltEs23(zwu73, zwu74, ty_Integer) → new_ltEs10(zwu73, zwu74)
new_ltEs4(zwu150, zwu152, app(ty_Maybe, ccc)) → new_ltEs9(zwu150, zwu152, ccc)
new_ltEs19(zwu732, zwu742, app(app(ty_Either, dc), dd)) → new_ltEs18(zwu732, zwu742, dc, dd)
new_esEs14(Just(zwu4000), Just(zwu6000), ty_Ordering) → new_esEs21(zwu4000, zwu6000)
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_esEs4(zwu400, zwu600, ty_Double) → new_esEs19(zwu400, zwu600)
new_esEs39(zwu4001, zwu6001, ty_Integer) → new_esEs25(zwu4001, zwu6001)
new_ltEs19(zwu732, zwu742, app(ty_[], cg)) → new_ltEs16(zwu732, zwu742, cg)
new_esEs10(zwu400, zwu600, app(app(ty_@2, ebh), eca)) → new_esEs17(zwu400, zwu600, ebh, eca)
new_lt20(zwu730, zwu740, ty_Integer) → new_lt10(zwu730, zwu740)
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_esEs22(Right(zwu4000), Right(zwu6000), egf, ty_Ordering) → new_esEs21(zwu4000, zwu6000)
new_esEs33(zwu4000, zwu6000, app(app(app(ty_@3, dgg), dgh), dha)) → new_esEs13(zwu4000, zwu6000, dgg, dgh, dha)
new_compare111(zwu233, zwu234, zwu235, zwu236, zwu237, zwu238, False, zwu240, eef, eeg, eeh) → new_compare114(zwu233, zwu234, zwu235, zwu236, zwu237, zwu238, zwu240, eef, eeg, eeh)
new_esEs34(zwu4001, zwu6001, ty_Float) → new_esEs23(zwu4001, zwu6001)
new_ltEs24(zwu118, zwu119, ty_Bool) → new_ltEs6(zwu118, zwu119)
new_esEs6(zwu401, zwu601, ty_Double) → new_esEs19(zwu401, zwu601)
new_ltEs18(Right(zwu730), Right(zwu740), bdc, app(ty_[], bdh)) → new_ltEs16(zwu730, zwu740, bdh)
new_ltEs5(LT, GT) → True
new_esEs31(zwu136, zwu139, ty_@0) → new_esEs20(zwu136, zwu139)
new_ltEs18(Left(zwu730), Left(zwu740), ty_Int, bcb) → new_ltEs15(zwu730, zwu740)
new_ltEs23(zwu73, zwu74, app(ty_[], ga)) → new_ltEs16(zwu73, zwu74, ga)
new_esEs39(zwu4001, zwu6001, app(app(app(ty_@3, feh), ffa), ffb)) → new_esEs13(zwu4001, zwu6001, feh, ffa, ffb)
new_ltEs13(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), ca, cb, df) → new_pePe(new_lt20(zwu730, zwu740, ca), new_asAs(new_esEs28(zwu730, zwu740, ca), new_pePe(new_lt19(zwu731, zwu741, cb), new_asAs(new_esEs29(zwu731, zwu741, cb), new_ltEs19(zwu732, zwu742, df)))))
new_primMulInt(Neg(zwu4000), Neg(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_compare114(zwu233, zwu234, zwu235, zwu236, zwu237, zwu238, False, eef, eeg, eeh) → GT
new_ltEs19(zwu732, zwu742, ty_Integer) → new_ltEs10(zwu732, zwu742)
new_esEs22(Left(zwu4000), Left(zwu6000), ty_Char, eff) → new_esEs18(zwu4000, zwu6000)
new_ltEs9(Just(zwu730), Just(zwu740), ty_@0) → new_ltEs12(zwu730, zwu740)
new_esEs39(zwu4001, zwu6001, ty_Ordering) → new_esEs21(zwu4001, zwu6001)
new_ltEs4(zwu150, zwu152, ty_Float) → new_ltEs14(zwu150, zwu152)
new_primEqNat0(Succ(zwu40000), Zero) → False
new_primEqNat0(Zero, Succ(zwu60000)) → False
new_esEs34(zwu4001, zwu6001, ty_Integer) → new_esEs25(zwu4001, zwu6001)
new_compare113(zwu248, zwu249, zwu250, zwu251, False, eed, eee) → GT
new_primPlusNat0(Zero, Zero) → Zero
new_lt5(zwu149, zwu151, ty_@0) → new_lt12(zwu149, zwu151)
new_ltEs9(Just(zwu730), Just(zwu740), app(app(app(ty_@3, ba), bb), bc)) → new_ltEs13(zwu730, zwu740, ba, bb, bc)
new_lt20(zwu730, zwu740, app(app(ty_Either, fg), fh)) → new_lt18(zwu730, zwu740, fg, fh)
new_ltEs9(Just(zwu730), Just(zwu740), ty_Integer) → new_ltEs10(zwu730, zwu740)
new_esEs7(zwu402, zwu602, ty_Ordering) → new_esEs21(zwu402, zwu602)
new_ltEs18(Right(zwu730), Right(zwu740), bdc, ty_Char) → new_ltEs11(zwu730, zwu740)
new_primEqInt(Pos(Zero), Pos(Zero)) → True
new_lt23(zwu137, zwu140, ty_Char) → new_lt11(zwu137, zwu140)
new_ltEs18(Left(zwu730), Left(zwu740), ty_Float, bcb) → new_ltEs14(zwu730, zwu740)
new_compare8(LT, LT) → EQ
new_ltEs18(Left(zwu730), Left(zwu740), app(ty_[], bcf), bcb) → new_ltEs16(zwu730, zwu740, bcf)
new_esEs11(zwu400, zwu600, app(app(ty_@2, edb), edc)) → new_esEs17(zwu400, zwu600, edb, edc)
new_esEs14(Just(zwu4000), Just(zwu6000), ty_Bool) → new_esEs16(zwu4000, zwu6000)
new_ltEs22(zwu138, zwu141, ty_Double) → new_ltEs8(zwu138, zwu141)
new_esEs5(zwu400, zwu600, app(app(app(ty_@3, cgb), cgc), cgd)) → new_esEs13(zwu400, zwu600, cgb, cgc, cgd)
new_ltEs9(Just(zwu730), Just(zwu740), ty_Float) → new_ltEs14(zwu730, zwu740)
new_compare8(EQ, GT) → LT
new_esEs40(zwu4002, zwu6002, ty_Float) → new_esEs23(zwu4002, zwu6002)
new_ltEs21(zwu731, zwu741, ty_Integer) → new_ltEs10(zwu731, zwu741)
new_esEs6(zwu401, zwu601, app(app(app(ty_@3, chd), che), chf)) → new_esEs13(zwu401, zwu601, chd, che, chf)
new_compare8(GT, EQ) → GT
new_lt19(zwu731, zwu741, ty_@0) → new_lt12(zwu731, zwu741)
new_compare7(zwu400, zwu600, ty_Integer) → new_compare12(zwu400, zwu600)
new_esEs13(@3(zwu4000, zwu4001, zwu4002), @3(zwu6000, zwu6001, zwu6002), faa, fab, fac) → new_asAs(new_esEs38(zwu4000, zwu6000, faa), new_asAs(new_esEs39(zwu4001, zwu6001, fab), new_esEs40(zwu4002, zwu6002, fac)))
new_esEs6(zwu401, zwu601, app(ty_[], chh)) → new_esEs15(zwu401, zwu601, chh)
new_esEs10(zwu400, zwu600, app(ty_Ratio, ecd)) → new_esEs24(zwu400, zwu600, ecd)
new_esEs27(zwu149, zwu151, ty_Bool) → new_esEs16(zwu149, zwu151)
new_lt23(zwu137, zwu140, app(ty_[], caa)) → new_lt16(zwu137, zwu140, caa)
new_esEs34(zwu4001, zwu6001, ty_Ordering) → new_esEs21(zwu4001, zwu6001)
new_compare18(Right(zwu400), Right(zwu600), cdd, cde) → new_compare28(zwu400, zwu600, new_esEs11(zwu400, zwu600, cde), cdd, cde)
new_esEs22(Right(zwu4000), Right(zwu6000), egf, app(ty_Maybe, ehb)) → new_esEs14(zwu4000, zwu6000, ehb)
new_esEs16(True, True) → True
new_esEs33(zwu4000, zwu6000, ty_Ordering) → new_esEs21(zwu4000, zwu6000)
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_esEs10(zwu400, zwu600, ty_Ordering) → new_esEs21(zwu400, zwu600)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_esEs30(zwu730, zwu740, ty_Char) → new_esEs18(zwu730, zwu740)
new_compare13(Char(zwu400), Char(zwu600)) → new_primCmpNat0(zwu400, zwu600)
new_esEs12(zwu400, zwu600) → new_primEqInt(zwu400, zwu600)
new_esEs4(zwu400, zwu600, app(app(ty_Either, egf), eff)) → new_esEs22(zwu400, zwu600, egf, eff)
new_ltEs22(zwu138, zwu141, ty_@0) → new_ltEs12(zwu138, zwu141)
new_compare7(zwu400, zwu600, app(ty_Ratio, dbh)) → new_compare10(zwu400, zwu600, dbh)
new_lt5(zwu149, zwu151, ty_Float) → new_lt14(zwu149, zwu151)
new_esEs28(zwu730, zwu740, app(app(ty_@2, fd), ff)) → new_esEs17(zwu730, zwu740, fd, ff)
new_ltEs20(zwu111, zwu112, app(app(app(ty_@3, cdh), cea), ceb)) → new_ltEs13(zwu111, zwu112, cdh, cea, ceb)
new_ltEs19(zwu732, zwu742, ty_Double) → new_ltEs8(zwu732, zwu742)
new_esEs32(zwu137, zwu140, ty_Bool) → new_esEs16(zwu137, zwu140)
new_ltEs21(zwu731, zwu741, ty_Float) → new_ltEs14(zwu731, zwu741)
new_esEs15(:(zwu4000, zwu4001), [], fae) → False
new_esEs15([], :(zwu6000, zwu6001), fae) → False
new_ltEs24(zwu118, zwu119, app(ty_Maybe, cfa)) → new_ltEs9(zwu118, zwu119, cfa)
new_primCompAux0(zwu400, zwu600, zwu57, gb) → new_primCompAux00(zwu57, new_compare7(zwu400, zwu600, gb))
new_compare10(:%(zwu400, zwu401), :%(zwu600, zwu601), ty_Int) → new_compare16(new_sr(zwu400, zwu601), new_sr(zwu600, zwu401))
new_esEs39(zwu4001, zwu6001, ty_Char) → new_esEs18(zwu4001, zwu6001)
new_ltEs20(zwu111, zwu112, app(ty_[], cec)) → new_ltEs16(zwu111, zwu112, cec)
new_esEs31(zwu136, zwu139, app(app(app(ty_@3, bfc), bfd), bfe)) → new_esEs13(zwu136, zwu139, bfc, bfd, bfe)
new_lt19(zwu731, zwu741, ty_Double) → new_lt9(zwu731, zwu741)
new_lt20(zwu730, zwu740, app(ty_[], fc)) → new_lt16(zwu730, zwu740, fc)
new_ltEs18(Right(zwu730), Right(zwu740), bdc, app(app(app(ty_@3, bde), bdf), bdg)) → new_ltEs13(zwu730, zwu740, bde, bdf, bdg)
new_esEs22(Right(zwu4000), Right(zwu6000), egf, ty_Char) → new_esEs18(zwu4000, zwu6000)
new_esEs27(zwu149, zwu151, app(ty_Maybe, cah)) → new_esEs14(zwu149, zwu151, cah)
new_ltEs9(Just(zwu730), Just(zwu740), app(app(ty_@2, be), bf)) → new_ltEs17(zwu730, zwu740, be, bf)
new_ltEs23(zwu73, zwu74, ty_Bool) → new_ltEs6(zwu73, zwu74)
new_esEs34(zwu4001, zwu6001, ty_Int) → new_esEs12(zwu4001, zwu6001)
new_compare29(zwu73, zwu74, True, eeb) → EQ
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_lt17(zwu40, zwu60, caf, cag) → new_esEs26(new_compare17(zwu40, zwu60, caf, cag))
new_ltEs22(zwu138, zwu141, app(ty_[], bgh)) → new_ltEs16(zwu138, zwu141, bgh)
new_ltEs4(zwu150, zwu152, ty_Integer) → new_ltEs10(zwu150, zwu152)
new_esEs11(zwu400, zwu600, app(app(app(ty_@3, ece), ecf), ecg)) → new_esEs13(zwu400, zwu600, ece, ecf, ecg)
new_compare6(Just(zwu400), Nothing, hd) → GT
new_lt21(zwu730, zwu740, ty_Char) → new_lt11(zwu730, zwu740)
new_ltEs7(zwu73, zwu74, edg) → new_fsEs(new_compare10(zwu73, zwu74, edg))
new_esEs34(zwu4001, zwu6001, app(ty_Ratio, ebb)) → new_esEs24(zwu4001, zwu6001, ebb)
new_esEs30(zwu730, zwu740, app(app(app(ty_@3, bba), bbb), bbc)) → new_esEs13(zwu730, zwu740, bba, bbb, bbc)
new_esEs29(zwu731, zwu741, ty_Double) → new_esEs19(zwu731, zwu741)
new_esEs14(Nothing, Nothing, fad) → True
new_asAs(False, zwu174) → False
new_esEs38(zwu4000, zwu6000, ty_Int) → new_esEs12(zwu4000, zwu6000)
new_esEs6(zwu401, zwu601, app(app(ty_Either, dac), dad)) → new_esEs22(zwu401, zwu601, dac, dad)
new_esEs33(zwu4000, zwu6000, ty_Float) → new_esEs23(zwu4000, zwu6000)
new_esEs28(zwu730, zwu740, ty_Float) → new_esEs23(zwu730, zwu740)
new_esEs14(Just(zwu4000), Just(zwu6000), ty_Integer) → new_esEs25(zwu4000, zwu6000)
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Pos(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_ltEs19(zwu732, zwu742, ty_Char) → new_ltEs11(zwu732, zwu742)
new_compare16(zwu40, zwu60) → new_primCmpInt(zwu40, zwu60)
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_ltEs19(zwu732, zwu742, ty_Float) → new_ltEs14(zwu732, zwu742)
new_ltEs18(Right(zwu730), Right(zwu740), bdc, ty_Ordering) → new_ltEs5(zwu730, zwu740)
new_compare11(Double(zwu400, zwu401), Double(zwu600, zwu601)) → new_compare16(new_sr(zwu400, zwu600), new_sr(zwu401, zwu601))
new_ltEs5(LT, EQ) → True
new_esEs39(zwu4001, zwu6001, ty_Float) → new_esEs23(zwu4001, zwu6001)
new_esEs4(zwu400, zwu600, ty_Bool) → new_esEs16(zwu400, zwu600)
new_ltEs18(Right(zwu730), Right(zwu740), bdc, ty_Double) → new_ltEs8(zwu730, zwu740)
new_esEs37(zwu4001, zwu6001, ty_Integer) → new_esEs25(zwu4001, zwu6001)
new_lt21(zwu730, zwu740, app(ty_Maybe, bag)) → new_lt4(zwu730, zwu740, bag)
new_lt21(zwu730, zwu740, app(app(app(ty_@3, bba), bbb), bbc)) → new_lt13(zwu730, zwu740, bba, bbb, bbc)
new_ltEs23(zwu73, zwu74, app(app(app(ty_@3, ca), cb), df)) → new_ltEs13(zwu73, zwu74, ca, cb, df)
new_lt14(zwu40, zwu60) → new_esEs26(new_compare15(zwu40, zwu60))
new_ltEs20(zwu111, zwu112, ty_Bool) → new_ltEs6(zwu111, zwu112)
new_ltEs4(zwu150, zwu152, app(app(ty_@2, cch), cda)) → new_ltEs17(zwu150, zwu152, cch, cda)
new_esEs37(zwu4001, zwu6001, ty_Int) → new_esEs12(zwu4001, zwu6001)
new_esEs10(zwu400, zwu600, ty_@0) → new_esEs20(zwu400, zwu600)
new_esEs33(zwu4000, zwu6000, app(ty_Maybe, dhb)) → new_esEs14(zwu4000, zwu6000, dhb)
new_esEs36(zwu4000, zwu6000, ty_Int) → new_esEs12(zwu4000, zwu6000)
new_compare7(zwu400, zwu600, app(app(ty_@2, gh), ha)) → new_compare17(zwu400, zwu600, gh, ha)
new_esEs33(zwu4000, zwu6000, app(ty_Ratio, dhh)) → new_esEs24(zwu4000, zwu6000, dhh)
new_esEs34(zwu4001, zwu6001, ty_Bool) → new_esEs16(zwu4001, zwu6001)
new_esEs5(zwu400, zwu600, app(ty_Maybe, cge)) → new_esEs14(zwu400, zwu600, cge)
new_esEs23(Float(zwu4000, zwu4001), Float(zwu6000, zwu6001)) → new_esEs12(new_sr(zwu4000, zwu6000), new_sr(zwu4001, zwu6001))
new_ltEs4(zwu150, zwu152, app(ty_[], ccg)) → new_ltEs16(zwu150, zwu152, ccg)
new_compare114(zwu233, zwu234, zwu235, zwu236, zwu237, zwu238, True, eef, eeg, eeh) → LT
new_esEs25(Integer(zwu4000), Integer(zwu6000)) → new_primEqInt(zwu4000, zwu6000)
new_esEs10(zwu400, zwu600, app(ty_Maybe, ebf)) → new_esEs14(zwu400, zwu600, ebf)
new_compare111(zwu233, zwu234, zwu235, zwu236, zwu237, zwu238, True, zwu240, eef, eeg, eeh) → new_compare114(zwu233, zwu234, zwu235, zwu236, zwu237, zwu238, True, eef, eeg, eeh)
new_lt5(zwu149, zwu151, app(app(ty_Either, cbh), cca)) → new_lt18(zwu149, zwu151, cbh, cca)
new_esEs38(zwu4000, zwu6000, app(ty_Ratio, feg)) → new_esEs24(zwu4000, zwu6000, feg)
new_lt22(zwu136, zwu139, app(app(ty_Either, bga), bgb)) → new_lt18(zwu136, zwu139, bga, bgb)
new_ltEs21(zwu731, zwu741, ty_@0) → new_ltEs12(zwu731, zwu741)
new_ltEs4(zwu150, zwu152, ty_Int) → new_ltEs15(zwu150, zwu152)
new_esEs10(zwu400, zwu600, ty_Bool) → new_esEs16(zwu400, zwu600)
new_lt22(zwu136, zwu139, ty_Double) → new_lt9(zwu136, zwu139)
new_ltEs23(zwu73, zwu74, app(app(ty_@2, he), bah)) → new_ltEs17(zwu73, zwu74, he, bah)
new_compare8(EQ, LT) → GT
new_esEs39(zwu4001, zwu6001, app(ty_Ratio, fga)) → new_esEs24(zwu4001, zwu6001, fga)
new_lt5(zwu149, zwu151, ty_Char) → new_lt11(zwu149, zwu151)
new_esEs14(Just(zwu4000), Just(zwu6000), ty_Float) → new_esEs23(zwu4000, zwu6000)
new_esEs22(Left(zwu4000), Left(zwu6000), app(app(ty_@2, ega), egb), eff) → new_esEs17(zwu4000, zwu6000, ega, egb)
new_esEs16(False, False) → True
new_lt19(zwu731, zwu741, app(app(app(ty_@3, dg), dh), ea)) → new_lt13(zwu731, zwu741, dg, dh, ea)
new_compare28(zwu118, zwu119, False, ceh, efa) → new_compare115(zwu118, zwu119, new_ltEs24(zwu118, zwu119, efa), ceh, efa)
new_esEs14(Just(zwu4000), Just(zwu6000), app(app(app(ty_@3, fcd), fce), fcf)) → new_esEs13(zwu4000, zwu6000, fcd, fce, fcf)
new_esEs38(zwu4000, zwu6000, ty_Float) → new_esEs23(zwu4000, zwu6000)
new_compare5(@3(zwu400, zwu401, zwu402), @3(zwu600, zwu601, zwu602), bee, bef, beg) → new_compare25(zwu400, zwu401, zwu402, zwu600, zwu601, zwu602, new_asAs(new_esEs5(zwu400, zwu600, bee), new_asAs(new_esEs6(zwu401, zwu601, bef), new_esEs7(zwu402, zwu602, beg))), bee, bef, beg)
new_compare9(False, True) → LT
new_esEs32(zwu137, zwu140, app(app(ty_@2, cab), cac)) → new_esEs17(zwu137, zwu140, cab, cac)
new_esEs40(zwu4002, zwu6002, ty_Bool) → new_esEs16(zwu4002, zwu6002)
new_esEs11(zwu400, zwu600, ty_Double) → new_esEs19(zwu400, zwu600)
new_esEs30(zwu730, zwu740, app(ty_Maybe, bag)) → new_esEs14(zwu730, zwu740, bag)
new_esEs30(zwu730, zwu740, app(app(ty_Either, bbg), bbh)) → new_esEs22(zwu730, zwu740, bbg, bbh)
new_esEs27(zwu149, zwu151, ty_Integer) → new_esEs25(zwu149, zwu151)
new_esEs21(LT, GT) → False
new_esEs21(GT, LT) → False
new_esEs8(zwu400, zwu600, app(app(ty_@2, dch), dda)) → new_esEs17(zwu400, zwu600, dch, dda)
new_lt22(zwu136, zwu139, ty_Integer) → new_lt10(zwu136, zwu139)
new_ltEs18(Left(zwu730), Left(zwu740), ty_Bool, bcb) → new_ltEs6(zwu730, zwu740)
new_esEs5(zwu400, zwu600, app(app(ty_@2, cgg), cgh)) → new_esEs17(zwu400, zwu600, cgg, cgh)
new_ltEs23(zwu73, zwu74, ty_Ordering) → new_ltEs5(zwu73, zwu74)
new_esEs30(zwu730, zwu740, ty_Int) → new_esEs12(zwu730, zwu740)
new_lt23(zwu137, zwu140, app(app(ty_@2, cab), cac)) → new_lt17(zwu137, zwu140, cab, cac)
new_esEs40(zwu4002, zwu6002, ty_Double) → new_esEs19(zwu4002, zwu6002)
new_lt19(zwu731, zwu741, app(ty_Maybe, de)) → new_lt4(zwu731, zwu741, de)
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_ltEs19(zwu732, zwu742, ty_Int) → new_ltEs15(zwu732, zwu742)
new_ltEs24(zwu118, zwu119, app(app(ty_Either, cfh), cga)) → new_ltEs18(zwu118, zwu119, cfh, cga)
new_esEs4(zwu400, zwu600, ty_Ordering) → new_esEs21(zwu400, zwu600)
new_esEs6(zwu401, zwu601, app(ty_Maybe, chg)) → new_esEs14(zwu401, zwu601, chg)
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_ltEs22(zwu138, zwu141, app(app(ty_@2, bha), bhb)) → new_ltEs17(zwu138, zwu141, bha, bhb)
new_ltEs20(zwu111, zwu112, ty_Double) → new_ltEs8(zwu111, zwu112)
new_ltEs23(zwu73, zwu74, ty_@0) → new_ltEs12(zwu73, zwu74)
new_lt5(zwu149, zwu151, ty_Ordering) → new_lt6(zwu149, zwu151)
new_esEs7(zwu402, zwu602, ty_Bool) → new_esEs16(zwu402, zwu602)
new_esEs22(Right(zwu4000), Right(zwu6000), egf, ty_Double) → new_esEs19(zwu4000, zwu6000)
new_esEs31(zwu136, zwu139, ty_Char) → new_esEs18(zwu136, zwu139)
new_ltEs18(Left(zwu730), Left(zwu740), app(ty_Ratio, dfd), bcb) → new_ltEs7(zwu730, zwu740, dfd)
new_compare9(True, True) → EQ
new_ltEs9(Just(zwu730), Just(zwu740), app(app(ty_Either, bg), bh)) → new_ltEs18(zwu730, zwu740, bg, bh)
new_esEs30(zwu730, zwu740, ty_Double) → new_esEs19(zwu730, zwu740)
new_compare112(zwu165, zwu166, False, eec) → GT
new_ltEs21(zwu731, zwu741, ty_Bool) → new_ltEs6(zwu731, zwu741)
new_ltEs4(zwu150, zwu152, ty_Ordering) → new_ltEs5(zwu150, zwu152)
new_lt21(zwu730, zwu740, app(app(ty_Either, bbg), bbh)) → new_lt18(zwu730, zwu740, bbg, bbh)
new_esEs29(zwu731, zwu741, app(app(ty_Either, ee), ef)) → new_esEs22(zwu731, zwu741, ee, ef)
new_lt12(zwu40, zwu60) → new_esEs26(new_compare14(zwu40, zwu60))
new_esEs31(zwu136, zwu139, ty_Float) → new_esEs23(zwu136, zwu139)
new_lt19(zwu731, zwu741, ty_Char) → new_lt11(zwu731, zwu741)
new_esEs8(zwu400, zwu600, ty_Bool) → new_esEs16(zwu400, zwu600)
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_esEs35(zwu4000, zwu6000, app(ty_[], fbc)) → new_esEs15(zwu4000, zwu6000, fbc)
new_lt8(zwu40, zwu60, fcc) → new_esEs26(new_compare10(zwu40, zwu60, fcc))
new_esEs28(zwu730, zwu740, ty_Int) → new_esEs12(zwu730, zwu740)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_ltEs19(zwu732, zwu742, ty_Ordering) → new_ltEs5(zwu732, zwu742)
new_esEs22(Left(zwu4000), Left(zwu6000), ty_Double, eff) → new_esEs19(zwu4000, zwu6000)
new_compare0([], :(zwu600, zwu601), gb) → LT
new_esEs6(zwu401, zwu601, app(ty_Ratio, dae)) → new_esEs24(zwu401, zwu601, dae)
new_esEs7(zwu402, zwu602, ty_Char) → new_esEs18(zwu402, zwu602)
new_esEs35(zwu4000, zwu6000, ty_Integer) → new_esEs25(zwu4000, zwu6000)
new_esEs39(zwu4001, zwu6001, app(ty_Maybe, ffc)) → new_esEs14(zwu4001, zwu6001, ffc)
new_esEs26(LT) → True
new_ltEs4(zwu150, zwu152, app(ty_Ratio, dcb)) → new_ltEs7(zwu150, zwu152, dcb)
new_compare26(zwu149, zwu150, zwu151, zwu152, True, ccb, cba) → EQ
new_esEs7(zwu402, zwu602, ty_@0) → new_esEs20(zwu402, zwu602)
new_asAs(True, zwu174) → zwu174
new_compare115(zwu189, zwu190, False, fca, fcb) → GT
new_ltEs22(zwu138, zwu141, ty_Bool) → new_ltEs6(zwu138, zwu141)
new_ltEs19(zwu732, zwu742, app(ty_Ratio, dfa)) → new_ltEs7(zwu732, zwu742, dfa)
new_compare25(zwu136, zwu137, zwu138, zwu139, zwu140, zwu141, False, bgc, bfa, bfb) → new_compare111(zwu136, zwu137, zwu138, zwu139, zwu140, zwu141, new_lt22(zwu136, zwu139, bgc), new_asAs(new_esEs31(zwu136, zwu139, bgc), new_pePe(new_lt23(zwu137, zwu140, bfa), new_asAs(new_esEs32(zwu137, zwu140, bfa), new_ltEs22(zwu138, zwu141, bfb)))), bgc, bfa, bfb)
new_esEs9(zwu401, zwu601, ty_Double) → new_esEs19(zwu401, zwu601)
new_esEs6(zwu401, zwu601, ty_Integer) → new_esEs25(zwu401, zwu601)
new_esEs29(zwu731, zwu741, ty_Ordering) → new_esEs21(zwu731, zwu741)
new_ltEs5(GT, GT) → True
new_esEs9(zwu401, zwu601, ty_Bool) → new_esEs16(zwu401, zwu601)
new_esEs34(zwu4001, zwu6001, app(ty_Maybe, ead)) → new_esEs14(zwu4001, zwu6001, ead)
new_esEs32(zwu137, zwu140, ty_Double) → new_esEs19(zwu137, zwu140)
new_lt5(zwu149, zwu151, ty_Double) → new_lt9(zwu149, zwu151)
new_esEs4(zwu400, zwu600, ty_Char) → new_esEs18(zwu400, zwu600)
new_ltEs18(Left(zwu730), Left(zwu740), ty_Char, bcb) → new_ltEs11(zwu730, zwu740)
new_esEs10(zwu400, zwu600, app(app(ty_Either, ecb), ecc)) → new_esEs22(zwu400, zwu600, ecb, ecc)
new_esEs33(zwu4000, zwu6000, ty_Char) → new_esEs18(zwu4000, zwu6000)
new_ltEs21(zwu731, zwu741, app(app(ty_Either, bae), baf)) → new_ltEs18(zwu731, zwu741, bae, baf)
new_lt5(zwu149, zwu151, app(app(ty_@2, cbf), cbg)) → new_lt17(zwu149, zwu151, cbf, cbg)
new_ltEs21(zwu731, zwu741, ty_Int) → new_ltEs15(zwu731, zwu741)
new_esEs29(zwu731, zwu741, app(ty_[], eb)) → new_esEs15(zwu731, zwu741, eb)
new_esEs22(Left(zwu4000), Right(zwu6000), egf, eff) → False
new_esEs22(Right(zwu4000), Left(zwu6000), egf, eff) → False
new_ltEs6(False, False) → True
new_esEs5(zwu400, zwu600, app(app(ty_Either, cha), chb)) → new_esEs22(zwu400, zwu600, cha, chb)
new_esEs9(zwu401, zwu601, ty_Char) → new_esEs18(zwu401, zwu601)
new_compare7(zwu400, zwu600, ty_Bool) → new_compare9(zwu400, zwu600)
new_compare27(zwu111, zwu112, False, dfb, cdg) → new_compare110(zwu111, zwu112, new_ltEs20(zwu111, zwu112, dfb), dfb, cdg)
new_esEs17(@2(zwu4000, zwu4001), @2(zwu6000, zwu6001), dge, dgf) → new_asAs(new_esEs33(zwu4000, zwu6000, dge), new_esEs34(zwu4001, zwu6001, dgf))
new_esEs21(LT, EQ) → False
new_esEs21(EQ, LT) → False
new_lt23(zwu137, zwu140, app(app(ty_Either, cad), cae)) → new_lt18(zwu137, zwu140, cad, cae)
new_compare6(Nothing, Just(zwu600), hd) → LT
new_ltEs21(zwu731, zwu741, ty_Char) → new_ltEs11(zwu731, zwu741)
new_lt19(zwu731, zwu741, app(ty_Ratio, deh)) → new_lt8(zwu731, zwu741, deh)
new_esEs27(zwu149, zwu151, ty_Char) → new_esEs18(zwu149, zwu151)
new_compare19(zwu248, zwu249, zwu250, zwu251, True, zwu253, eed, eee) → new_compare113(zwu248, zwu249, zwu250, zwu251, True, eed, eee)
new_esEs28(zwu730, zwu740, ty_Char) → new_esEs18(zwu730, zwu740)
new_esEs4(zwu400, zwu600, app(ty_Maybe, fad)) → new_esEs14(zwu400, zwu600, fad)
new_esEs30(zwu730, zwu740, app(ty_[], bbd)) → new_esEs15(zwu730, zwu740, bbd)
new_lt19(zwu731, zwu741, app(app(ty_@2, ec), ed)) → new_lt17(zwu731, zwu741, ec, ed)
new_lt23(zwu137, zwu140, ty_Int) → new_lt15(zwu137, zwu140)
new_esEs11(zwu400, zwu600, app(app(ty_Either, edd), ede)) → new_esEs22(zwu400, zwu600, edd, ede)
new_ltEs24(zwu118, zwu119, app(app(app(ty_@3, cfb), cfc), cfd)) → new_ltEs13(zwu118, zwu119, cfb, cfc, cfd)
new_esEs34(zwu4001, zwu6001, app(app(app(ty_@3, eaa), eab), eac)) → new_esEs13(zwu4001, zwu6001, eaa, eab, eac)
new_compare8(GT, LT) → GT
new_lt5(zwu149, zwu151, app(ty_Maybe, cah)) → new_lt4(zwu149, zwu151, cah)
new_esEs8(zwu400, zwu600, ty_Double) → new_esEs19(zwu400, zwu600)
new_ltEs22(zwu138, zwu141, ty_Int) → new_ltEs15(zwu138, zwu141)
new_primCompAux00(zwu94, GT) → GT
new_esEs7(zwu402, zwu602, app(ty_Maybe, dba)) → new_esEs14(zwu402, zwu602, dba)
new_ltEs4(zwu150, zwu152, ty_Char) → new_ltEs11(zwu150, zwu152)
new_fsEs(zwu255) → new_not(new_esEs21(zwu255, GT))
new_lt20(zwu730, zwu740, app(ty_Maybe, eg)) → new_lt4(zwu730, zwu740, eg)
new_ltEs22(zwu138, zwu141, app(ty_Maybe, bgd)) → new_ltEs9(zwu138, zwu141, bgd)
new_esEs39(zwu4001, zwu6001, ty_Int) → new_esEs12(zwu4001, zwu6001)
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_ltEs5(GT, EQ) → False
new_esEs32(zwu137, zwu140, ty_Char) → new_esEs18(zwu137, zwu140)
new_esEs31(zwu136, zwu139, ty_Ordering) → new_esEs21(zwu136, zwu139)
new_ltEs16(zwu73, zwu74, ga) → new_fsEs(new_compare0(zwu73, zwu74, ga))
new_compare19(zwu248, zwu249, zwu250, zwu251, False, zwu253, eed, eee) → new_compare113(zwu248, zwu249, zwu250, zwu251, zwu253, eed, eee)
new_lt7(zwu40, zwu60) → new_esEs26(new_compare9(zwu40, zwu60))
new_primEqInt(Pos(Zero), Neg(Zero)) → True
new_primEqInt(Neg(Zero), Pos(Zero)) → True
new_esEs22(Right(zwu4000), Right(zwu6000), egf, app(app(ty_Either, ehf), ehg)) → new_esEs22(zwu4000, zwu6000, ehf, ehg)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_esEs30(zwu730, zwu740, ty_Float) → new_esEs23(zwu730, zwu740)
new_not(True) → False
new_esEs32(zwu137, zwu140, ty_Ordering) → new_esEs21(zwu137, zwu140)
new_esEs27(zwu149, zwu151, ty_Double) → new_esEs19(zwu149, zwu151)

The set Q consists of the following terms:

new_lt19(x0, x1, app(app(ty_@2, x2), x3))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs33(x0, x1, app(app(ty_@2, x2), x3))
new_esEs28(x0, x1, app(ty_Ratio, x2))
new_compare9(False, True)
new_compare9(True, False)
new_compare8(EQ, LT)
new_compare8(LT, EQ)
new_esEs38(x0, x1, ty_Float)
new_esEs32(x0, x1, ty_Double)
new_ltEs18(Right(x0), Right(x1), x2, ty_Ordering)
new_esEs21(LT, LT)
new_ltEs22(x0, x1, app(app(ty_@2, x2), x3))
new_esEs8(x0, x1, ty_Float)
new_primMulNat0(Zero, Succ(x0))
new_esEs5(x0, x1, ty_Double)
new_esEs5(x0, x1, app(ty_[], x2))
new_lt23(x0, x1, ty_Char)
new_esEs38(x0, x1, ty_Bool)
new_ltEs22(x0, x1, ty_Char)
new_esEs21(LT, EQ)
new_esEs21(EQ, LT)
new_ltEs19(x0, x1, ty_Float)
new_esEs9(x0, x1, app(app(ty_Either, x2), x3))
new_esEs32(x0, x1, ty_Int)
new_esEs8(x0, x1, app(ty_Maybe, x2))
new_esEs22(Right(x0), Right(x1), x2, app(app(ty_Either, x3), x4))
new_lt5(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs9(x0, x1, ty_Integer)
new_esEs29(x0, x1, app(ty_Ratio, x2))
new_lt21(x0, x1, ty_Int)
new_lt23(x0, x1, app(app(ty_Either, x2), x3))
new_ltEs9(Just(x0), Just(x1), app(app(ty_@2, x2), x3))
new_ltEs23(x0, x1, ty_Char)
new_ltEs18(Left(x0), Left(x1), ty_Int, x2)
new_esEs35(x0, x1, app(app(ty_Either, x2), x3))
new_esEs11(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_primEqInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_esEs8(x0, x1, app(app(ty_@2, x2), x3))
new_esEs40(x0, x1, ty_Bool)
new_esEs10(x0, x1, app(app(ty_Either, x2), x3))
new_ltEs18(Right(x0), Right(x1), x2, app(app(app(ty_@3, x3), x4), x5))
new_esEs4(x0, x1, ty_Int)
new_ltEs21(x0, x1, app(app(ty_@2, x2), x3))
new_lt22(x0, x1, app(app(ty_Either, x2), x3))
new_esEs38(x0, x1, ty_Integer)
new_ltEs22(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs7(x0, x1, ty_Int)
new_ltEs18(Right(x0), Right(x1), x2, ty_Int)
new_primEqInt(Neg(Succ(x0)), Pos(x1))
new_primEqInt(Pos(Succ(x0)), Neg(x1))
new_primEqInt(Neg(Zero), Neg(Succ(x0)))
new_ltEs9(Just(x0), Just(x1), app(app(app(ty_@3, x2), x3), x4))
new_ltEs18(Right(x0), Right(x1), x2, ty_Bool)
new_esEs9(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs27(x0, x1, ty_Int)
new_lt5(x0, x1, app(app(ty_Either, x2), x3))
new_esEs15(:(x0, x1), :(x2, x3), x4)
new_esEs30(x0, x1, ty_Ordering)
new_esEs29(x0, x1, ty_Bool)
new_esEs27(x0, x1, ty_Bool)
new_esEs35(x0, x1, ty_Int)
new_esEs8(x0, x1, ty_Integer)
new_sr(x0, x1)
new_lt21(x0, x1, ty_Ordering)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_esEs7(x0, x1, ty_Integer)
new_esEs14(Just(x0), Just(x1), ty_Char)
new_lt7(x0, x1)
new_lt19(x0, x1, ty_@0)
new_esEs9(x0, x1, app(ty_Maybe, x2))
new_esEs11(x0, x1, app(ty_Maybe, x2))
new_ltEs21(x0, x1, ty_Bool)
new_esEs35(x0, x1, ty_@0)
new_ltEs20(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs4(x0, x1, ty_Float)
new_esEs35(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs6(x0, x1, app(ty_[], x2))
new_esEs22(Right(x0), Right(x1), x2, app(app(app(ty_@3, x3), x4), x5))
new_esEs9(x0, x1, ty_Float)
new_ltEs21(x0, x1, ty_Int)
new_esEs39(x0, x1, app(app(ty_@2, x2), x3))
new_esEs38(x0, x1, app(ty_Ratio, x2))
new_compare115(x0, x1, False, x2, x3)
new_compare113(x0, x1, x2, x3, True, x4, x5)
new_ltEs23(x0, x1, ty_Bool)
new_ltEs21(x0, x1, app(ty_[], x2))
new_compare27(x0, x1, True, x2, x3)
new_ltEs24(x0, x1, ty_Int)
new_ltEs18(Left(x0), Left(x1), ty_Ordering, x2)
new_lt20(x0, x1, ty_@0)
new_esEs30(x0, x1, ty_@0)
new_ltEs23(x0, x1, ty_Double)
new_esEs27(x0, x1, app(ty_Ratio, x2))
new_ltEs24(x0, x1, ty_Double)
new_ltEs5(GT, EQ)
new_ltEs5(EQ, GT)
new_esEs27(x0, x1, app(ty_[], x2))
new_esEs22(Right(x0), Right(x1), x2, ty_Float)
new_ltEs18(Right(x0), Right(x1), x2, ty_Float)
new_esEs4(x0, x1, app(app(ty_@2, x2), x3))
new_primCompAux00(x0, EQ)
new_esEs11(x0, x1, app(app(ty_@2, x2), x3))
new_esEs39(x0, x1, ty_Integer)
new_esEs33(x0, x1, app(ty_Ratio, x2))
new_esEs22(Right(x0), Right(x1), x2, ty_Integer)
new_esEs40(x0, x1, app(app(ty_Either, x2), x3))
new_lt22(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs39(x0, x1, ty_Ordering)
new_ltEs4(x0, x1, app(ty_Ratio, x2))
new_compare10(:%(x0, x1), :%(x2, x3), ty_Int)
new_esEs30(x0, x1, ty_Bool)
new_esEs7(x0, x1, ty_Float)
new_esEs30(x0, x1, app(ty_Ratio, x2))
new_ltEs20(x0, x1, ty_Float)
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_esEs14(Just(x0), Just(x1), ty_Int)
new_compare29(x0, x1, False, x2)
new_esEs22(Right(x0), Right(x1), x2, app(app(ty_@2, x3), x4))
new_lt21(x0, x1, app(app(ty_@2, x2), x3))
new_esEs33(x0, x1, app(app(ty_Either, x2), x3))
new_ltEs24(x0, x1, app(app(ty_Either, x2), x3))
new_ltEs23(x0, x1, app(ty_Ratio, x2))
new_ltEs22(x0, x1, ty_Double)
new_compare9(True, True)
new_lt20(x0, x1, app(ty_Ratio, x2))
new_esEs33(x0, x1, app(ty_[], x2))
new_esEs11(x0, x1, ty_Int)
new_esEs34(x0, x1, ty_Bool)
new_esEs6(x0, x1, ty_@0)
new_lt23(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_ltEs9(Just(x0), Just(x1), ty_Char)
new_lt5(x0, x1, ty_@0)
new_ltEs6(True, True)
new_ltEs7(x0, x1, x2)
new_lt19(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_ltEs9(Just(x0), Just(x1), ty_Double)
new_esEs22(Left(x0), Left(x1), ty_Int, x2)
new_esEs28(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs16(True, False)
new_esEs16(False, True)
new_esEs34(x0, x1, ty_Ordering)
new_ltEs20(x0, x1, ty_Double)
new_esEs9(x0, x1, ty_Double)
new_lt5(x0, x1, ty_Char)
new_compare6(Nothing, Nothing, x0)
new_primEqInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_esEs36(x0, x1, ty_Int)
new_esEs39(x0, x1, ty_@0)
new_primPlusNat0(Succ(x0), Zero)
new_ltEs22(x0, x1, ty_Integer)
new_esEs21(EQ, GT)
new_esEs21(GT, EQ)
new_esEs38(x0, x1, app(ty_[], x2))
new_compare29(x0, x1, True, x2)
new_lt19(x0, x1, ty_Bool)
new_esEs28(x0, x1, ty_@0)
new_ltEs18(Right(x0), Right(x1), x2, app(ty_[], x3))
new_esEs16(True, True)
new_compare7(x0, x1, app(ty_Ratio, x2))
new_esEs4(x0, x1, ty_Bool)
new_primPlusNat0(Zero, Succ(x0))
new_compare11(Double(x0, x1), Double(x2, x3))
new_esEs27(x0, x1, app(app(ty_Either, x2), x3))
new_ltEs18(Left(x0), Left(x1), ty_Bool, x2)
new_esEs40(x0, x1, ty_Integer)
new_esEs29(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs31(x0, x1, app(ty_Ratio, x2))
new_esEs11(x0, x1, app(ty_Ratio, x2))
new_lt20(x0, x1, app(ty_Maybe, x2))
new_esEs5(x0, x1, ty_Float)
new_ltEs21(x0, x1, app(app(ty_Either, x2), x3))
new_ltEs5(LT, EQ)
new_ltEs5(EQ, LT)
new_lt20(x0, x1, ty_Ordering)
new_lt21(x0, x1, ty_Char)
new_ltEs19(x0, x1, ty_@0)
new_esEs6(x0, x1, ty_Char)
new_primEqNat0(Zero, Zero)
new_esEs28(x0, x1, app(app(ty_@2, x2), x3))
new_esEs28(x0, x1, ty_Bool)
new_lt5(x0, x1, ty_Float)
new_esEs26(EQ)
new_esEs9(x0, x1, app(ty_[], x2))
new_esEs10(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs8(x0, x1, ty_Char)
new_esEs36(x0, x1, ty_Integer)
new_ltEs12(x0, x1)
new_primEqInt(Pos(Zero), Pos(Succ(x0)))
new_esEs28(x0, x1, ty_Char)
new_esEs37(x0, x1, ty_Int)
new_ltEs4(x0, x1, ty_Double)
new_ltEs9(Just(x0), Just(x1), ty_Int)
new_esEs31(x0, x1, app(ty_[], x2))
new_esEs30(x0, x1, app(ty_[], x2))
new_ltEs18(Left(x0), Left(x1), ty_Integer, x2)
new_ltEs9(Nothing, Just(x0), x1)
new_compare7(x0, x1, ty_Bool)
new_compare111(x0, x1, x2, x3, x4, x5, True, x6, x7, x8, x9)
new_esEs14(Nothing, Just(x0), x1)
new_ltEs9(Just(x0), Just(x1), ty_Integer)
new_ltEs11(x0, x1)
new_esEs11(x0, x1, ty_Float)
new_esEs27(x0, x1, ty_Float)
new_lt23(x0, x1, app(ty_Ratio, x2))
new_esEs39(x0, x1, ty_Double)
new_esEs6(x0, x1, app(ty_Ratio, x2))
new_ltEs9(Nothing, Nothing, x0)
new_esEs30(x0, x1, ty_Float)
new_compare110(x0, x1, True, x2, x3)
new_lt20(x0, x1, app(ty_[], x2))
new_esEs6(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs9(x0, x1, app(app(ty_@2, x2), x3))
new_lt20(x0, x1, ty_Double)
new_primMulNat0(Zero, Zero)
new_sr0(Integer(x0), Integer(x1))
new_esEs22(Left(x0), Left(x1), ty_Ordering, x2)
new_esEs35(x0, x1, ty_Float)
new_esEs14(Just(x0), Just(x1), app(ty_Maybe, x2))
new_esEs22(Left(x0), Left(x1), app(app(app(ty_@3, x2), x3), x4), x5)
new_esEs22(Right(x0), Right(x1), x2, ty_Char)
new_ltEs22(x0, x1, app(ty_[], x2))
new_compare114(x0, x1, x2, x3, x4, x5, False, x6, x7, x8)
new_compare15(Float(x0, x1), Float(x2, x3))
new_esEs8(x0, x1, ty_Bool)
new_lt15(x0, x1)
new_esEs34(x0, x1, app(ty_[], x2))
new_esEs31(x0, x1, app(app(ty_Either, x2), x3))
new_esEs35(x0, x1, ty_Bool)
new_ltEs22(x0, x1, ty_Int)
new_esEs15(:(x0, x1), [], x2)
new_ltEs24(x0, x1, app(ty_Ratio, x2))
new_esEs26(GT)
new_lt21(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs10(x0, x1, app(app(ty_@2, x2), x3))
new_esEs30(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs4(x0, x1, ty_Double)
new_esEs14(Just(x0), Just(x1), app(ty_Ratio, x2))
new_ltEs19(x0, x1, ty_Ordering)
new_ltEs18(Left(x0), Left(x1), app(ty_Maybe, x2), x3)
new_ltEs23(x0, x1, app(ty_[], x2))
new_esEs4(x0, x1, ty_@0)
new_ltEs15(x0, x1)
new_ltEs20(x0, x1, ty_Char)
new_esEs32(x0, x1, app(ty_[], x2))
new_lt4(x0, x1, x2)
new_ltEs9(Just(x0), Just(x1), app(app(ty_Either, x2), x3))
new_lt19(x0, x1, ty_Double)
new_ltEs4(x0, x1, app(ty_Maybe, x2))
new_lt22(x0, x1, app(ty_[], x2))
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_ltEs20(x0, x1, ty_Bool)
new_esEs22(Right(x0), Right(x1), x2, ty_Double)
new_lt20(x0, x1, ty_Float)
new_esEs11(x0, x1, app(app(ty_Either, x2), x3))
new_lt5(x0, x1, ty_Double)
new_esEs28(x0, x1, ty_Int)
new_esEs29(x0, x1, ty_Int)
new_lt23(x0, x1, ty_Bool)
new_esEs8(x0, x1, ty_Ordering)
new_ltEs19(x0, x1, app(ty_Maybe, x2))
new_ltEs4(x0, x1, ty_Int)
new_compare0(:(x0, x1), [], x2)
new_esEs39(x0, x1, ty_Char)
new_esEs10(x0, x1, app(ty_[], x2))
new_primCmpNat0(Succ(x0), Zero)
new_compare6(Just(x0), Just(x1), x2)
new_ltEs16(x0, x1, x2)
new_esEs31(x0, x1, ty_Char)
new_esEs9(x0, x1, app(ty_Ratio, x2))
new_compare115(x0, x1, True, x2, x3)
new_esEs7(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs22(Right(x0), Right(x1), x2, app(ty_Ratio, x3))
new_ltEs24(x0, x1, ty_@0)
new_lt23(x0, x1, app(ty_Maybe, x2))
new_esEs40(x0, x1, app(app(ty_@2, x2), x3))
new_compare8(EQ, EQ)
new_esEs15([], [], x0)
new_lt22(x0, x1, ty_Double)
new_ltEs22(x0, x1, ty_Float)
new_compare25(x0, x1, x2, x3, x4, x5, False, x6, x7, x8)
new_esEs29(x0, x1, app(ty_[], x2))
new_esEs34(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs13(@3(x0, x1, x2), @3(x3, x4, x5), x6, x7, x8)
new_ltEs4(x0, x1, ty_Bool)
new_esEs9(x0, x1, ty_Int)
new_ltEs18(Left(x0), Left(x1), app(ty_Ratio, x2), x3)
new_ltEs19(x0, x1, ty_Bool)
new_compare7(x0, x1, ty_@0)
new_ltEs18(Left(x0), Left(x1), ty_Float, x2)
new_ltEs20(x0, x1, ty_@0)
new_ltEs8(x0, x1)
new_ltEs21(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs10(x0, x1, ty_Integer)
new_lt19(x0, x1, ty_Char)
new_esEs29(x0, x1, ty_Float)
new_esEs33(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs10(x0, x1, ty_Char)
new_lt8(x0, x1, x2)
new_esEs5(x0, x1, app(app(ty_@2, x2), x3))
new_esEs28(x0, x1, app(ty_Maybe, x2))
new_esEs31(x0, x1, ty_Bool)
new_compare12(Integer(x0), Integer(x1))
new_esEs39(x0, x1, app(ty_Ratio, x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_ltEs19(x0, x1, ty_Double)
new_esEs10(x0, x1, ty_Int)
new_esEs29(x0, x1, app(app(ty_@2, x2), x3))
new_esEs33(x0, x1, ty_Bool)
new_esEs31(x0, x1, ty_@0)
new_lt21(x0, x1, ty_Bool)
new_esEs32(x0, x1, ty_Ordering)
new_compare0([], [], x0)
new_ltEs18(Right(x0), Right(x1), x2, app(app(ty_Either, x3), x4))
new_esEs14(Just(x0), Just(x1), ty_Ordering)
new_esEs22(Right(x0), Right(x1), x2, ty_Int)
new_esEs39(x0, x1, ty_Int)
new_esEs4(x0, x1, app(ty_Ratio, x2))
new_esEs40(x0, x1, ty_Float)
new_esEs28(x0, x1, ty_Double)
new_lt22(x0, x1, app(ty_Ratio, x2))
new_esEs30(x0, x1, ty_Double)
new_esEs7(x0, x1, ty_@0)
new_esEs27(x0, x1, ty_@0)
new_esEs12(x0, x1)
new_esEs31(x0, x1, ty_Int)
new_ltEs24(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_lt23(x0, x1, app(ty_[], x2))
new_lt5(x0, x1, app(ty_[], x2))
new_esEs30(x0, x1, ty_Integer)
new_ltEs19(x0, x1, app(ty_[], x2))
new_esEs14(Just(x0), Just(x1), ty_@0)
new_ltEs23(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_lt20(x0, x1, ty_Char)
new_primPlusNat0(Zero, Zero)
new_esEs18(Char(x0), Char(x1))
new_esEs6(x0, x1, ty_Int)
new_esEs39(x0, x1, app(ty_[], x2))
new_ltEs22(x0, x1, app(app(ty_Either, x2), x3))
new_ltEs4(x0, x1, app(app(ty_@2, x2), x3))
new_primMulNat0(Succ(x0), Zero)
new_ltEs4(x0, x1, ty_Ordering)
new_lt21(x0, x1, app(ty_[], x2))
new_esEs11(x0, x1, app(ty_[], x2))
new_esEs7(x0, x1, ty_Double)
new_ltEs19(x0, x1, app(app(ty_@2, x2), x3))
new_esEs15([], :(x0, x1), x2)
new_esEs8(x0, x1, ty_@0)
new_primCompAux0(x0, x1, x2, x3)
new_esEs22(Left(x0), Left(x1), ty_Double, x2)
new_compare8(GT, EQ)
new_compare8(EQ, GT)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_ltEs4(x0, x1, ty_@0)
new_esEs7(x0, x1, app(ty_Ratio, x2))
new_compare7(x0, x1, app(app(ty_@2, x2), x3))
new_esEs22(Left(x0), Left(x1), ty_Char, x2)
new_ltEs18(Left(x0), Left(x1), app(app(ty_@2, x2), x3), x4)
new_ltEs24(x0, x1, ty_Ordering)
new_esEs6(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs21(x0, x1, app(ty_Ratio, x2))
new_esEs6(x0, x1, app(app(ty_Either, x2), x3))
new_esEs34(x0, x1, app(ty_Maybe, x2))
new_esEs35(x0, x1, ty_Char)
new_ltEs23(x0, x1, ty_Ordering)
new_compare18(Right(x0), Right(x1), x2, x3)
new_lt23(x0, x1, ty_Ordering)
new_lt19(x0, x1, ty_Ordering)
new_ltEs4(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs34(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs35(x0, x1, ty_Integer)
new_ltEs6(True, False)
new_lt21(x0, x1, ty_Float)
new_ltEs6(False, True)
new_esEs21(LT, GT)
new_esEs21(GT, LT)
new_esEs14(Just(x0), Just(x1), ty_Double)
new_ltEs24(x0, x1, app(ty_[], x2))
new_compare113(x0, x1, x2, x3, False, x4, x5)
new_fsEs(x0)
new_lt19(x0, x1, app(ty_Ratio, x2))
new_esEs29(x0, x1, ty_Double)
new_lt20(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_ltEs18(Right(x0), Right(x1), x2, ty_Integer)
new_esEs34(x0, x1, ty_Char)
new_esEs38(x0, x1, ty_Int)
new_ltEs23(x0, x1, app(ty_Maybe, x2))
new_lt22(x0, x1, app(app(ty_@2, x2), x3))
new_esEs4(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs37(x0, x1, ty_Integer)
new_primEqNat0(Succ(x0), Succ(x1))
new_esEs29(x0, x1, ty_Ordering)
new_esEs29(x0, x1, app(ty_Maybe, x2))
new_ltEs9(Just(x0), Just(x1), ty_@0)
new_primEqInt(Neg(Succ(x0)), Neg(Zero))
new_esEs10(x0, x1, app(ty_Maybe, x2))
new_esEs22(Right(x0), Right(x1), x2, app(ty_Maybe, x3))
new_ltEs22(x0, x1, app(ty_Maybe, x2))
new_esEs4(x0, x1, app(ty_[], x2))
new_esEs40(x0, x1, ty_Char)
new_esEs11(x0, x1, ty_Char)
new_esEs5(x0, x1, ty_@0)
new_esEs32(x0, x1, ty_Integer)
new_ltEs19(x0, x1, app(ty_Ratio, x2))
new_lt22(x0, x1, app(ty_Maybe, x2))
new_esEs29(x0, x1, app(app(ty_Either, x2), x3))
new_esEs13(@3(x0, x1, x2), @3(x3, x4, x5), x6, x7, x8)
new_esEs5(x0, x1, ty_Char)
new_compare7(x0, x1, app(ty_[], x2))
new_ltEs4(x0, x1, app(ty_[], x2))
new_primMulInt(Neg(x0), Neg(x1))
new_primEqInt(Pos(Zero), Neg(Succ(x0)))
new_primEqInt(Neg(Zero), Pos(Succ(x0)))
new_compare112(x0, x1, False, x2)
new_lt19(x0, x1, app(app(ty_Either, x2), x3))
new_primEqInt(Pos(Zero), Neg(Zero))
new_primEqInt(Neg(Zero), Pos(Zero))
new_lt20(x0, x1, ty_Bool)
new_esEs7(x0, x1, ty_Ordering)
new_esEs33(x0, x1, ty_Integer)
new_primCmpNat0(Zero, Succ(x0))
new_esEs6(x0, x1, ty_Integer)
new_esEs6(x0, x1, ty_Double)
new_esEs32(x0, x1, app(ty_Maybe, x2))
new_esEs10(x0, x1, ty_Double)
new_compare112(x0, x1, True, x2)
new_esEs28(x0, x1, ty_Ordering)
new_ltEs18(Left(x0), Left(x1), ty_Double, x2)
new_esEs4(x0, x1, ty_Integer)
new_esEs14(Just(x0), Just(x1), app(app(ty_Either, x2), x3))
new_esEs22(Right(x0), Right(x1), x2, ty_@0)
new_esEs22(Right(x0), Right(x1), x2, ty_Bool)
new_esEs30(x0, x1, app(app(ty_Either, x2), x3))
new_esEs34(x0, x1, ty_Float)
new_esEs39(x0, x1, app(app(ty_Either, x2), x3))
new_compare19(x0, x1, x2, x3, True, x4, x5, x6)
new_esEs30(x0, x1, ty_Int)
new_esEs4(x0, x1, app(app(ty_Either, x2), x3))
new_compare7(x0, x1, ty_Ordering)
new_esEs7(x0, x1, ty_Char)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_ltEs6(False, False)
new_ltEs18(Right(x0), Right(x1), x2, app(app(ty_@2, x3), x4))
new_esEs33(x0, x1, ty_Double)
new_primEqInt(Pos(Succ(x0)), Pos(Zero))
new_compare26(x0, x1, x2, x3, True, x4, x5)
new_esEs28(x0, x1, ty_Integer)
new_esEs31(x0, x1, ty_Ordering)
new_ltEs18(Right(x0), Right(x1), x2, app(ty_Ratio, x3))
new_esEs34(x0, x1, ty_Integer)
new_primEqInt(Neg(Zero), Neg(Zero))
new_lt20(x0, x1, ty_Integer)
new_compare14(@0, @0)
new_ltEs21(x0, x1, app(ty_Maybe, x2))
new_lt17(x0, x1, x2, x3)
new_compare16(x0, x1)
new_lt22(x0, x1, ty_Ordering)
new_esEs40(x0, x1, app(ty_[], x2))
new_esEs14(Nothing, Nothing, x0)
new_lt5(x0, x1, ty_Bool)
new_ltEs20(x0, x1, app(ty_Maybe, x2))
new_esEs7(x0, x1, app(app(ty_Either, x2), x3))
new_esEs30(x0, x1, app(app(ty_@2, x2), x3))
new_esEs39(x0, x1, app(ty_Maybe, x2))
new_esEs22(Left(x0), Left(x1), ty_Integer, x2)
new_ltEs21(x0, x1, ty_Ordering)
new_ltEs19(x0, x1, ty_Char)
new_compare18(Left(x0), Left(x1), x2, x3)
new_esEs40(x0, x1, ty_Double)
new_lt9(x0, x1)
new_ltEs9(Just(x0), Just(x1), app(ty_Ratio, x2))
new_ltEs20(x0, x1, ty_Ordering)
new_esEs5(x0, x1, app(ty_Ratio, x2))
new_lt5(x0, x1, ty_Int)
new_esEs22(Left(x0), Left(x1), ty_Bool, x2)
new_ltEs9(Just(x0), Just(x1), app(ty_[], x2))
new_compare27(x0, x1, False, x2, x3)
new_lt6(x0, x1)
new_lt23(x0, x1, ty_Float)
new_primCompAux00(x0, LT)
new_esEs38(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs33(x0, x1, ty_Ordering)
new_lt20(x0, x1, app(app(ty_Either, x2), x3))
new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_esEs32(x0, x1, ty_Char)
new_compare8(GT, LT)
new_esEs27(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_compare8(LT, GT)
new_compare0(:(x0, x1), :(x2, x3), x4)
new_compare5(@3(x0, x1, x2), @3(x3, x4, x5), x6, x7, x8)
new_esEs27(x0, x1, ty_Integer)
new_compare7(x0, x1, ty_Float)
new_ltEs18(Right(x0), Right(x1), x2, ty_@0)
new_esEs4(x0, x1, ty_Char)
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_esEs32(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs33(x0, x1, ty_Float)
new_compare7(x0, x1, app(ty_Maybe, x2))
new_compare7(x0, x1, ty_Char)
new_ltEs4(x0, x1, ty_Char)
new_compare18(Left(x0), Right(x1), x2, x3)
new_compare18(Right(x0), Left(x1), x2, x3)
new_esEs10(x0, x1, ty_Float)
new_ltEs24(x0, x1, ty_Integer)
new_pePe(False, x0)
new_esEs29(x0, x1, ty_@0)
new_ltEs4(x0, x1, ty_Float)
new_esEs28(x0, x1, app(ty_[], x2))
new_lt22(x0, x1, ty_Float)
new_esEs6(x0, x1, ty_Ordering)
new_esEs14(Just(x0), Just(x1), app(app(app(ty_@3, x2), x3), x4))
new_lt14(x0, x1)
new_compare7(x0, x1, ty_Int)
new_esEs38(x0, x1, ty_Char)
new_esEs34(x0, x1, app(ty_Ratio, x2))
new_esEs38(x0, x1, app(ty_Maybe, x2))
new_esEs10(x0, x1, ty_@0)
new_esEs5(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_lt20(x0, x1, ty_Int)
new_ltEs5(LT, GT)
new_ltEs5(GT, LT)
new_esEs9(x0, x1, ty_@0)
new_ltEs19(x0, x1, ty_Int)
new_ltEs4(x0, x1, ty_Integer)
new_ltEs20(x0, x1, ty_Int)
new_lt22(x0, x1, ty_Int)
new_esEs26(LT)
new_ltEs19(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_ltEs21(x0, x1, ty_Double)
new_esEs35(x0, x1, app(app(ty_@2, x2), x3))
new_primCmpNat0(Zero, Zero)
new_ltEs23(x0, x1, ty_Int)
new_compare26(x0, x1, x2, x3, False, x4, x5)
new_esEs9(x0, x1, ty_Char)
new_esEs22(Right(x0), Right(x1), x2, app(ty_[], x3))
new_esEs31(x0, x1, ty_Double)
new_lt21(x0, x1, ty_Double)
new_asAs(True, x0)
new_compare7(x0, x1, ty_Integer)
new_ltEs9(Just(x0), Just(x1), ty_Bool)
new_esEs31(x0, x1, ty_Integer)
new_esEs7(x0, x1, ty_Bool)
new_compare0([], :(x0, x1), x2)
new_ltEs10(x0, x1)
new_esEs10(x0, x1, ty_Bool)
new_lt19(x0, x1, app(ty_[], x2))
new_esEs11(x0, x1, ty_Integer)
new_lt10(x0, x1)
new_lt23(x0, x1, app(app(ty_@2, x2), x3))
new_esEs4(x0, x1, app(ty_Maybe, x2))
new_esEs6(x0, x1, ty_Bool)
new_esEs31(x0, x1, ty_Float)
new_esEs8(x0, x1, app(ty_Ratio, x2))
new_esEs22(Left(x0), Left(x1), app(ty_[], x2), x3)
new_lt22(x0, x1, ty_@0)
new_esEs5(x0, x1, app(app(ty_Either, x2), x3))
new_ltEs18(Left(x0), Left(x1), app(app(ty_Either, x2), x3), x4)
new_compare10(:%(x0, x1), :%(x2, x3), ty_Integer)
new_ltEs18(Right(x0), Right(x1), x2, ty_Double)
new_esEs22(Left(x0), Left(x1), app(ty_Maybe, x2), x3)
new_esEs22(Left(x0), Left(x1), app(app(ty_Either, x2), x3), x4)
new_esEs6(x0, x1, ty_Float)
new_esEs14(Just(x0), Just(x1), ty_Integer)
new_esEs7(x0, x1, app(ty_[], x2))
new_compare8(GT, GT)
new_esEs7(x0, x1, app(ty_Maybe, x2))
new_esEs11(x0, x1, ty_Ordering)
new_esEs40(x0, x1, ty_Int)
new_ltEs23(x0, x1, app(app(ty_Either, x2), x3))
new_esEs35(x0, x1, app(ty_Maybe, x2))
new_esEs6(x0, x1, app(ty_Maybe, x2))
new_esEs38(x0, x1, ty_Ordering)
new_ltEs21(x0, x1, ty_@0)
new_esEs9(x0, x1, ty_Ordering)
new_ltEs5(GT, GT)
new_lt12(x0, x1)
new_primEqNat0(Zero, Succ(x0))
new_esEs16(False, False)
new_esEs38(x0, x1, ty_Double)
new_compare7(x0, x1, ty_Double)
new_compare8(LT, LT)
new_esEs14(Just(x0), Just(x1), ty_Bool)
new_esEs14(Just(x0), Just(x1), ty_Float)
new_esEs27(x0, x1, app(app(ty_@2, x2), x3))
new_esEs25(Integer(x0), Integer(x1))
new_esEs22(Left(x0), Left(x1), ty_@0, x2)
new_lt13(x0, x1, x2, x3, x4)
new_esEs9(x0, x1, ty_Bool)
new_ltEs20(x0, x1, app(app(ty_Either, x2), x3))
new_esEs28(x0, x1, ty_Float)
new_ltEs18(Left(x0), Left(x1), app(app(app(ty_@3, x2), x3), x4), x5)
new_lt21(x0, x1, app(app(ty_Either, x2), x3))
new_esEs39(x0, x1, ty_Float)
new_esEs5(x0, x1, ty_Bool)
new_ltEs22(x0, x1, ty_@0)
new_ltEs20(x0, x1, ty_Integer)
new_esEs31(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs14(Just(x0), Just(x1), app(app(ty_@2, x2), x3))
new_ltEs20(x0, x1, app(ty_[], x2))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_compare25(x0, x1, x2, x3, x4, x5, True, x6, x7, x8)
new_esEs32(x0, x1, app(app(ty_@2, x2), x3))
new_lt19(x0, x1, ty_Int)
new_esEs32(x0, x1, ty_@0)
new_not(True)
new_primCompAux00(x0, GT)
new_primEqNat0(Succ(x0), Zero)
new_ltEs20(x0, x1, app(ty_Ratio, x2))
new_esEs33(x0, x1, app(ty_Maybe, x2))
new_esEs34(x0, x1, app(app(ty_Either, x2), x3))
new_esEs22(Right(x0), Right(x1), x2, ty_Ordering)
new_ltEs19(x0, x1, app(app(ty_Either, x2), x3))
new_esEs39(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs27(x0, x1, ty_Double)
new_esEs40(x0, x1, app(ty_Ratio, x2))
new_lt22(x0, x1, ty_Integer)
new_compare111(x0, x1, x2, x3, x4, x5, False, x6, x7, x8, x9)
new_ltEs21(x0, x1, ty_Integer)
new_esEs34(x0, x1, ty_Int)
new_esEs34(x0, x1, ty_@0)
new_esEs14(Just(x0), Nothing, x1)
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_esEs40(x0, x1, ty_Ordering)
new_not(False)
new_esEs35(x0, x1, app(ty_[], x2))
new_esEs11(x0, x1, ty_Double)
new_ltEs21(x0, x1, ty_Float)
new_esEs10(x0, x1, ty_Ordering)
new_esEs39(x0, x1, ty_Bool)
new_lt18(x0, x1, x2, x3)
new_ltEs4(x0, x1, app(app(ty_Either, x2), x3))
new_lt5(x0, x1, app(ty_Ratio, x2))
new_esEs14(Just(x0), Just(x1), app(ty_[], x2))
new_esEs32(x0, x1, ty_Bool)
new_ltEs5(EQ, EQ)
new_lt22(x0, x1, ty_Char)
new_esEs27(x0, x1, ty_Char)
new_esEs30(x0, x1, ty_Char)
new_ltEs19(x0, x1, ty_Integer)
new_esEs31(x0, x1, app(app(ty_@2, x2), x3))
new_esEs8(x0, x1, ty_Double)
new_ltEs18(Right(x0), Right(x1), x2, app(ty_Maybe, x3))
new_esEs35(x0, x1, ty_Double)
new_ltEs9(Just(x0), Just(x1), ty_Ordering)
new_compare28(x0, x1, True, x2, x3)
new_esEs5(x0, x1, app(ty_Maybe, x2))
new_esEs20(@0, @0)
new_esEs5(x0, x1, ty_Ordering)
new_esEs32(x0, x1, ty_Float)
new_esEs4(x0, x1, ty_Ordering)
new_lt5(x0, x1, app(ty_Maybe, x2))
new_ltEs24(x0, x1, ty_Bool)
new_esEs35(x0, x1, app(ty_Ratio, x2))
new_esEs11(x0, x1, ty_@0)
new_ltEs23(x0, x1, ty_Integer)
new_esEs33(x0, x1, ty_@0)
new_lt21(x0, x1, app(ty_Maybe, x2))
new_ltEs23(x0, x1, ty_@0)
new_esEs5(x0, x1, ty_Int)
new_ltEs9(Just(x0), Just(x1), app(ty_Maybe, x2))
new_esEs21(EQ, EQ)
new_esEs19(Double(x0, x1), Double(x2, x3))
new_lt5(x0, x1, ty_Integer)
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_compare19(x0, x1, x2, x3, False, x4, x5, x6)
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_lt23(x0, x1, ty_Integer)
new_ltEs21(x0, x1, ty_Char)
new_ltEs18(Left(x0), Left(x1), ty_Char, x2)
new_ltEs24(x0, x1, ty_Char)
new_esEs5(x0, x1, ty_Integer)
new_compare110(x0, x1, False, x2, x3)
new_ltEs24(x0, x1, app(ty_Maybe, x2))
new_ltEs22(x0, x1, ty_Bool)
new_ltEs22(x0, x1, ty_Ordering)
new_lt20(x0, x1, app(app(ty_@2, x2), x3))
new_lt5(x0, x1, ty_Ordering)
new_esEs8(x0, x1, app(ty_[], x2))
new_esEs22(Left(x0), Left(x1), app(app(ty_@2, x2), x3), x4)
new_esEs34(x0, x1, ty_Double)
new_esEs7(x0, x1, app(app(ty_@2, x2), x3))
new_esEs38(x0, x1, app(app(ty_Either, x2), x3))
new_ltEs18(Right(x0), Left(x1), x2, x3)
new_ltEs18(Left(x0), Right(x1), x2, x3)
new_lt21(x0, x1, app(ty_Ratio, x2))
new_esEs17(@2(x0, x1), @2(x2, x3), x4, x5)
new_esEs22(Left(x0), Left(x1), app(ty_Ratio, x2), x3)
new_esEs8(x0, x1, ty_Int)
new_primCmpNat0(Succ(x0), Succ(x1))
new_esEs29(x0, x1, ty_Char)
new_compare6(Just(x0), Nothing, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_esEs38(x0, x1, app(app(ty_@2, x2), x3))
new_esEs33(x0, x1, ty_Int)
new_ltEs23(x0, x1, app(app(ty_@2, x2), x3))
new_lt21(x0, x1, ty_@0)
new_lt16(x0, x1, x2)
new_esEs40(x0, x1, app(ty_Maybe, x2))
new_ltEs9(Just(x0), Just(x1), ty_Float)
new_lt19(x0, x1, ty_Float)
new_esEs40(x0, x1, ty_@0)
new_primEqInt(Pos(Zero), Pos(Zero))
new_lt23(x0, x1, ty_Int)
new_ltEs18(Left(x0), Left(x1), app(ty_[], x2), x3)
new_lt22(x0, x1, ty_Bool)
new_compare28(x0, x1, False, x2, x3)
new_esEs29(x0, x1, ty_Integer)
new_asAs(False, x0)
new_ltEs20(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs18(Left(x0), Left(x1), ty_@0, x2)
new_esEs38(x0, x1, ty_@0)
new_esEs27(x0, x1, app(ty_Maybe, x2))
new_pePe(True, x0)
new_ltEs9(Just(x0), Nothing, x1)
new_lt19(x0, x1, app(ty_Maybe, x2))
new_esEs22(Left(x0), Right(x1), x2, x3)
new_esEs22(Right(x0), Left(x1), x2, x3)
new_compare17(@2(x0, x1), @2(x2, x3), x4, x5)
new_esEs22(Left(x0), Left(x1), ty_Float, x2)
new_ltEs23(x0, x1, ty_Float)
new_esEs21(GT, GT)
new_lt5(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs17(@2(x0, x1), @2(x2, x3), x4, x5)
new_ltEs18(Right(x0), Right(x1), x2, ty_Char)
new_ltEs24(x0, x1, app(app(ty_@2, x2), x3))
new_lt23(x0, x1, ty_Double)
new_ltEs14(x0, x1)
new_esEs11(x0, x1, ty_Bool)
new_esEs32(x0, x1, app(app(ty_Either, x2), x3))
new_lt23(x0, x1, ty_@0)
new_ltEs22(x0, x1, app(ty_Ratio, x2))
new_esEs30(x0, x1, app(ty_Maybe, x2))
new_esEs40(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs31(x0, x1, app(ty_Maybe, x2))
new_compare6(Nothing, Just(x0), x1)
new_esEs8(x0, x1, app(app(ty_Either, x2), x3))
new_esEs28(x0, x1, app(app(ty_Either, x2), x3))
new_compare13(Char(x0), Char(x1))
new_compare9(False, False)
new_esEs32(x0, x1, app(ty_Ratio, x2))
new_esEs8(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_lt21(x0, x1, ty_Integer)
new_esEs24(:%(x0, x1), :%(x2, x3), x4)
new_esEs23(Float(x0, x1), Float(x2, x3))
new_esEs33(x0, x1, ty_Char)
new_ltEs5(LT, LT)
new_esEs35(x0, x1, ty_Ordering)
new_compare7(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_lt19(x0, x1, ty_Integer)
new_compare114(x0, x1, x2, x3, x4, x5, True, x6, x7, x8)
new_esEs10(x0, x1, app(ty_Ratio, x2))
new_lt11(x0, x1)
new_ltEs24(x0, x1, ty_Float)
new_esEs27(x0, x1, ty_Ordering)
new_compare7(x0, x1, app(app(ty_Either, x2), x3))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_deleteMin(zwu80, zwu81, zwu82, Branch(zwu830, zwu831, zwu832, zwu833, zwu834), zwu84, h, ba) → new_deleteMin(zwu830, zwu831, zwu832, zwu833, zwu834, h, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_deleteMax(zwu90, zwu91, zwu92, zwu93, Branch(zwu940, zwu941, zwu942, zwu943, zwu944), h, ba) → new_deleteMax(zwu940, zwu941, zwu942, zwu943, zwu944, h, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_lt15(new_sr1(new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), h, ba)
new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_lt15(new_sr1(new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), h, ba)

The TRS R consists of the following rules:

new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba)
new_esEs26(GT) → False
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_esEs26(EQ) → False
new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primMulNat1(Zero) → Zero
new_compare16(zwu40, zwu60) → new_primCmpInt(zwu40, zwu60)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_esEs26(LT) → True
new_primPlusNat0(Zero, Zero) → Zero
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_lt15(zwu40, zwu60) → new_esEs26(new_compare16(zwu40, zwu60))
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_glueVBal3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_lt15(x0, x1)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_compare16(x0, x1)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_glueVBal3Size_l(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_lt15(new_sr1(new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), h, ba) at position [10] we obtained the following new rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_compare16(new_sr1(new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_compare16(new_sr1(new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)
new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_lt15(new_sr1(new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), h, ba)

The TRS R consists of the following rules:

new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba)
new_esEs26(GT) → False
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_esEs26(EQ) → False
new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primMulNat1(Zero) → Zero
new_compare16(zwu40, zwu60) → new_primCmpInt(zwu40, zwu60)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_esEs26(LT) → True
new_primPlusNat0(Zero, Zero) → Zero
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_lt15(zwu40, zwu60) → new_esEs26(new_compare16(zwu40, zwu60))
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_glueVBal3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_lt15(x0, x1)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_compare16(x0, x1)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_glueVBal3Size_l(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_lt15(new_sr1(new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), h, ba) at position [10] we obtained the following new rules:

new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_compare16(new_sr1(new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_compare16(new_sr1(new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)
new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_compare16(new_sr1(new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)

The TRS R consists of the following rules:

new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba)
new_esEs26(GT) → False
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_esEs26(EQ) → False
new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primMulNat1(Zero) → Zero
new_compare16(zwu40, zwu60) → new_primCmpInt(zwu40, zwu60)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_esEs26(LT) → True
new_primPlusNat0(Zero, Zero) → Zero
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_lt15(zwu40, zwu60) → new_esEs26(new_compare16(zwu40, zwu60))
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_glueVBal3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_lt15(x0, x1)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_compare16(x0, x1)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_glueVBal3Size_l(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QReductionProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_compare16(new_sr1(new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)
new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_compare16(new_sr1(new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)

The TRS R consists of the following rules:

new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)
new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba)
new_compare16(zwu40, zwu60) → new_primCmpInt(zwu40, zwu60)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_glueVBal3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_lt15(x0, x1)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_compare16(x0, x1)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_glueVBal3Size_l(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_lt15(x0, x1)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QReductionProof
                                                  ↳ QDP
                                                    ↳ Rewriting
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_compare16(new_sr1(new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)
new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_compare16(new_sr1(new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)

The TRS R consists of the following rules:

new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)
new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba)
new_compare16(zwu40, zwu60) → new_primCmpInt(zwu40, zwu60)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_glueVBal3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_compare16(x0, x1)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_glueVBal3Size_l(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_compare16(new_sr1(new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba) at position [10,0] we obtained the following new rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QReductionProof
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)
new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_compare16(new_sr1(new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)

The TRS R consists of the following rules:

new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)
new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba)
new_compare16(zwu40, zwu60) → new_primCmpInt(zwu40, zwu60)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_glueVBal3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_compare16(x0, x1)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_glueVBal3Size_l(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_compare16(new_sr1(new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba) at position [10,0] we obtained the following new rules:

new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QReductionProof
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)

The TRS R consists of the following rules:

new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)
new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba)
new_compare16(zwu40, zwu60) → new_primCmpInt(zwu40, zwu60)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_glueVBal3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_compare16(x0, x1)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_glueVBal3Size_l(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QReductionProof
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)

The TRS R consists of the following rules:

new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba)
new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_glueVBal3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_compare16(x0, x1)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_glueVBal3Size_l(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_compare16(x0, x1)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QReductionProof
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)

The TRS R consists of the following rules:

new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba)
new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_glueVBal3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_glueVBal3Size_l(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba) at position [10,0,0,0] we obtained the following new rules:

new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba)), new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QReductionProof
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)
new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba)), new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)

The TRS R consists of the following rules:

new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba)
new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_glueVBal3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_glueVBal3Size_l(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba) at position [10,0,0,0] we obtained the following new rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QReductionProof
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)
new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba)), new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)

The TRS R consists of the following rules:

new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba)
new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_glueVBal3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_glueVBal3Size_l(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba)), new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba) at position [10,0,0,0] we obtained the following new rules:

new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu92), new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QReductionProof
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu92), new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)

The TRS R consists of the following rules:

new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba)
new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_glueVBal3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_glueVBal3Size_l(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba) at position [10,0,0,0] we obtained the following new rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu82), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QReductionProof
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu92), new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu82), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)

The TRS R consists of the following rules:

new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba)
new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_glueVBal3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_glueVBal3Size_l(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu92), new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba) at position [10,0,1] we obtained the following new rules:

new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu92), new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QReductionProof
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ UsableRulesProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu92), new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu82), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)

The TRS R consists of the following rules:

new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba)
new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_glueVBal3Size_r(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba)
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_glueVBal3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_glueVBal3Size_l(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QReductionProof
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ UsableRulesProof
                                                                                          ↳ QDP
                                                                                            ↳ QReductionProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu92), new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu82), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)

The TRS R consists of the following rules:

new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba)

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_glueVBal3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_glueVBal3Size_l(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_glueVBal3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QReductionProof
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ UsableRulesProof
                                                                                          ↳ QDP
                                                                                            ↳ QReductionProof
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu92), new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu82), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)

The TRS R consists of the following rules:

new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba)

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_glueVBal3Size_l(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu92), new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba) at position [10,0,1] we obtained the following new rules:

new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu92), zwu82)), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QReductionProof
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ UsableRulesProof
                                                                                          ↳ QDP
                                                                                            ↳ QReductionProof
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu82), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)
new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu92), zwu82)), h, ba)

The TRS R consists of the following rules:

new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba)

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_glueVBal3Size_l(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu82), new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba))), h, ba) at position [10,0,1] we obtained the following new rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu82), new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QReductionProof
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ UsableRulesProof
                                                                                          ↳ QDP
                                                                                            ↳ QReductionProof
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ UsableRulesProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu82), new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba))), h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)
new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu92), zwu82)), h, ba)

The TRS R consists of the following rules:

new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_glueVBal3Size_l(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba)

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_glueVBal3Size_l(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QReductionProof
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ UsableRulesProof
                                                                                          ↳ QDP
                                                                                            ↳ QReductionProof
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ UsableRulesProof
                                                                                                          ↳ QDP
                                                                                                            ↳ QReductionProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu82), new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba))), h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)
new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu92), zwu82)), h, ba)

The TRS R consists of the following rules:

new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_glueVBal3Size_l(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_glueVBal3Size_l(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QReductionProof
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ UsableRulesProof
                                                                                          ↳ QDP
                                                                                            ↳ QReductionProof
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ UsableRulesProof
                                                                                                          ↳ QDP
                                                                                                            ↳ QReductionProof
                                                                                                              ↳ QDP
                                                                                                                ↳ Rewriting
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu82), new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba))), h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)
new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu92), zwu82)), h, ba)

The TRS R consists of the following rules:

new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu82), new_sizeFM(zwu90, zwu91, zwu92, zwu93, zwu94, h, ba))), h, ba) at position [10,0,1] we obtained the following new rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu82), zwu92)), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QReductionProof
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ UsableRulesProof
                                                                                          ↳ QDP
                                                                                            ↳ QReductionProof
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ UsableRulesProof
                                                                                                          ↳ QDP
                                                                                                            ↳ QReductionProof
                                                                                                              ↳ QDP
                                                                                                                ↳ Rewriting
                                                                                                                  ↳ QDP
                                                                                                                    ↳ UsableRulesProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu82), zwu92)), h, ba)
new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu92), zwu82)), h, ba)

The TRS R consists of the following rules:

new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QReductionProof
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ UsableRulesProof
                                                                                          ↳ QDP
                                                                                            ↳ QReductionProof
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ UsableRulesProof
                                                                                                          ↳ QDP
                                                                                                            ↳ QReductionProof
                                                                                                              ↳ QDP
                                                                                                                ↳ Rewriting
                                                                                                                  ↳ QDP
                                                                                                                    ↳ UsableRulesProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ QReductionProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu82), zwu92)), h, ba)
new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu92), zwu82)), h, ba)

The TRS R consists of the following rules:

new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_sizeFM(x0, x1, x2, x3, x4, x5, x6)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QReductionProof
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ UsableRulesProof
                                                                                          ↳ QDP
                                                                                            ↳ QReductionProof
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ UsableRulesProof
                                                                                                          ↳ QDP
                                                                                                            ↳ QReductionProof
                                                                                                              ↳ QDP
                                                                                                                ↳ Rewriting
                                                                                                                  ↳ QDP
                                                                                                                    ↳ UsableRulesProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ QReductionProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ QDPOrderProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)
new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu82), zwu92)), h, ba)
new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu92), zwu82)), h, ba)

The TRS R consists of the following rules:

new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, False, h, ba) → new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu82), zwu92)), h, ba)
The remaining pairs can at least be oriented weakly.

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)
new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu92), zwu82)), h, ba)
Used ordering: Polynomial interpretation [25]:

POL(Branch(x1, x2, x3, x4, x5)) = 1 + x1 + x4 + x5   
POL(EQ) = 0   
POL(False) = 0   
POL(GT) = 0   
POL(LT) = 0   
POL(Neg(x1)) = 0   
POL(Pos(x1)) = 0   
POL(Succ(x1)) = 0   
POL(True) = 0   
POL(Zero) = 1   
POL(new_esEs26(x1)) = 0   
POL(new_glueVBal(x1, x2, x3, x4)) = x1   
POL(new_glueVBal3GlueVBal1(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)) = x4 + x5   
POL(new_glueVBal3GlueVBal2(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)) = 1 + x1 + x4 + x5   
POL(new_primCmpInt(x1, x2)) = 0   
POL(new_primCmpNat0(x1, x2)) = 0   
POL(new_primMulNat1(x1)) = x1   
POL(new_primPlusNat0(x1, x2)) = 0   
POL(new_sr1(x1)) = 0   

The following usable rules [17] were oriented: none



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QReductionProof
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ UsableRulesProof
                                                                                          ↳ QDP
                                                                                            ↳ QReductionProof
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ UsableRulesProof
                                                                                                          ↳ QDP
                                                                                                            ↳ QReductionProof
                                                                                                              ↳ QDP
                                                                                                                ↳ Rewriting
                                                                                                                  ↳ QDP
                                                                                                                    ↳ UsableRulesProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ QReductionProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ QDPOrderProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ DependencyGraphProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal3GlueVBal1(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(zwu94, Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba)
new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu92), zwu82)), h, ba)

The TRS R consists of the following rules:

new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QReductionProof
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ UsableRulesProof
                                                                                          ↳ QDP
                                                                                            ↳ QReductionProof
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ UsableRulesProof
                                                                                                          ↳ QDP
                                                                                                            ↳ QReductionProof
                                                                                                              ↳ QDP
                                                                                                                ↳ Rewriting
                                                                                                                  ↳ QDP
                                                                                                                    ↳ UsableRulesProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ QReductionProof
                                                                                                                          ↳ QDP
                                                                                                                            ↳ QDPOrderProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ QDPSizeChangeProof
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, True, h, ba) → new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), zwu83, h, ba)
new_glueVBal(Branch(zwu90, zwu91, zwu92, zwu93, zwu94), Branch(zwu80, zwu81, zwu82, zwu83, zwu84), h, ba) → new_glueVBal3GlueVBal2(zwu90, zwu91, zwu92, zwu93, zwu94, zwu80, zwu81, zwu82, zwu83, zwu84, new_esEs26(new_primCmpInt(new_sr1(zwu92), zwu82)), h, ba)

The TRS R consists of the following rules:

new_sr1(Neg(zwu540)) → Neg(new_primMulNat1(zwu540))
new_sr1(Pos(zwu540)) → Pos(new_primMulNat1(zwu540))
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)

The set Q consists of the following terms:

new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr1(Pos(x0))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primCmpNat0(Succ(x0), Zero)
new_sr1(Neg(x0))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primPlusNat0(Succ(x0), Zero)

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof
                                  ↳ QDP
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_addToFM_C2(zwu19, zwu20, zwu21, zwu22, zwu23, zwu24, zwu25, False, h, ba) → new_addToFM_C1(zwu19, zwu20, zwu21, zwu22, zwu23, zwu24, zwu25, new_gt(zwu24, zwu19, h), h, ba)
new_addToFM_C1(zwu36, zwu37, zwu38, zwu39, zwu40, zwu41, zwu42, True, bb, bc) → new_addToFM_C(zwu40, zwu41, zwu42, bb, bc)
new_addToFM_C2(zwu19, zwu20, zwu21, zwu22, zwu23, zwu24, zwu25, True, h, ba) → new_addToFM_C(zwu22, zwu24, zwu25, h, ba)
new_addToFM_C(Branch(zwu60, zwu61, zwu62, zwu63, zwu64), zwu40, zwu41, bd, be) → new_addToFM_C2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu40, zwu41, new_lt24(zwu40, zwu60, bd), bd, be)

The TRS R consists of the following rules:

new_ltEs23(zwu73, zwu74, app(ty_Maybe, dfh)) → new_ltEs9(zwu73, zwu74, dfh)
new_esEs33(zwu4000, zwu6000, ty_Integer) → new_esEs25(zwu4000, zwu6000)
new_ltEs23(zwu73, zwu74, app(app(ty_Either, cff), cec)) → new_ltEs18(zwu73, zwu74, cff, cec)
new_esEs18(Char(zwu4000), Char(zwu6000)) → new_primEqNat0(zwu4000, zwu6000)
new_lt23(zwu137, zwu140, ty_@0) → new_lt12(zwu137, zwu140)
new_esEs5(zwu400, zwu600, ty_Double) → new_esEs19(zwu400, zwu600)
new_esEs22(Left(zwu4000), Left(zwu6000), ty_Int, ehg) → new_esEs12(zwu4000, zwu6000)
new_esEs22(Left(zwu4000), Left(zwu6000), app(app(app(ty_@3, ehd), ehe), ehf), ehg) → new_esEs13(zwu4000, zwu6000, ehd, ehe, ehf)
new_ltEs18(Left(zwu730), Left(zwu740), ty_@0, cec) → new_ltEs12(zwu730, zwu740)
new_compare110(zwu179, zwu180, True, eeg, eeh) → LT
new_ltEs9(Just(zwu730), Just(zwu740), ty_Ordering) → new_ltEs5(zwu730, zwu740)
new_esEs8(zwu400, zwu600, ty_Integer) → new_esEs25(zwu400, zwu600)
new_lt20(zwu730, zwu740, ty_Char) → new_lt11(zwu730, zwu740)
new_esEs22(Right(zwu4000), Right(zwu6000), fag, app(ty_[], fbd)) → new_esEs15(zwu4000, zwu6000, fbd)
new_esEs40(zwu4002, zwu6002, app(app(ty_Either, gba), gbb)) → new_esEs22(zwu4002, zwu6002, gba, gbb)
new_ltEs9(Nothing, Just(zwu740), dfh) → True
new_esEs11(zwu400, zwu600, ty_Ordering) → new_esEs21(zwu400, zwu600)
new_esEs40(zwu4002, zwu6002, app(ty_[], gaf)) → new_esEs15(zwu4002, zwu6002, gaf)
new_esEs14(Just(zwu4000), Just(zwu6000), app(ty_Ratio, ffe)) → new_esEs24(zwu4000, zwu6000, ffe)
new_esEs39(zwu4001, zwu6001, app(app(ty_Either, fhg), fhh)) → new_esEs22(zwu4001, zwu6001, fhg, fhh)
new_gt(zwu24, zwu19, app(app(ty_@2, bdf), bdg)) → new_esEs41(new_compare17(zwu24, zwu19, bdf, bdg))
new_ltEs6(True, False) → False
new_compare9(True, False) → GT
new_compare8(LT, GT) → LT
new_esEs22(Left(zwu4000), Left(zwu6000), app(ty_[], faa), ehg) → new_esEs15(zwu4000, zwu6000, faa)
new_esEs32(zwu137, zwu140, ty_Int) → new_esEs12(zwu137, zwu140)
new_ltEs24(zwu118, zwu119, app(ty_Ratio, egb)) → new_ltEs7(zwu118, zwu119, egb)
new_ltEs18(Right(zwu730), Right(zwu740), cff, app(ty_Ratio, cfg)) → new_ltEs7(zwu730, zwu740, cfg)
new_lt21(zwu730, zwu740, ty_Ordering) → new_lt6(zwu730, zwu740)
new_esEs28(zwu730, zwu740, ty_Bool) → new_esEs16(zwu730, zwu740)
new_esEs27(zwu149, zwu151, app(ty_[], bba)) → new_esEs15(zwu149, zwu151, bba)
new_esEs22(Left(zwu4000), Left(zwu6000), ty_@0, ehg) → new_esEs20(zwu4000, zwu6000)
new_esEs28(zwu730, zwu740, app(ty_Maybe, bhb)) → new_esEs14(zwu730, zwu740, bhb)
new_gt(zwu24, zwu19, app(ty_Ratio, bch)) → new_esEs41(new_compare10(zwu24, zwu19, bch))
new_esEs11(zwu400, zwu600, ty_Integer) → new_esEs25(zwu400, zwu600)
new_esEs38(zwu4000, zwu6000, ty_Integer) → new_esEs25(zwu4000, zwu6000)
new_esEs22(Left(zwu4000), Left(zwu6000), app(ty_Maybe, ehh), ehg) → new_esEs14(zwu4000, zwu6000, ehh)
new_ltEs24(zwu118, zwu119, ty_Double) → new_ltEs8(zwu118, zwu119)
new_esEs11(zwu400, zwu600, app(ty_Ratio, eee)) → new_esEs24(zwu400, zwu600, eee)
new_esEs31(zwu136, zwu139, app(ty_Maybe, dcc)) → new_esEs14(zwu136, zwu139, dcc)
new_esEs14(Just(zwu4000), Just(zwu6000), app(app(ty_@2, ffa), ffb)) → new_esEs17(zwu4000, zwu6000, ffa, ffb)
new_esEs10(zwu400, zwu600, ty_Int) → new_esEs12(zwu400, zwu600)
new_lt21(zwu730, zwu740, app(ty_Ratio, chc)) → new_lt8(zwu730, zwu740, chc)
new_lt23(zwu137, zwu140, app(ty_Ratio, ddd)) → new_lt8(zwu137, zwu140, ddd)
new_ltEs9(Just(zwu730), Just(zwu740), ty_Int) → new_ltEs15(zwu730, zwu740)
new_esEs40(zwu4002, zwu6002, app(ty_Maybe, gae)) → new_esEs14(zwu4002, zwu6002, gae)
new_compare0(:(zwu400, zwu401), :(zwu600, zwu601), gb) → new_primCompAux0(zwu400, zwu600, new_compare0(zwu401, zwu601, gb), gb)
new_lt22(zwu136, zwu139, app(ty_Ratio, dcb)) → new_lt8(zwu136, zwu139, dcb)
new_ltEs5(EQ, LT) → False
new_gt(zwu24, zwu19, app(ty_[], bde)) → new_esEs41(new_compare0(zwu24, zwu19, bde))
new_esEs14(Just(zwu4000), Just(zwu6000), ty_Int) → new_esEs12(zwu4000, zwu6000)
new_esEs7(zwu402, zwu602, app(ty_[], fb)) → new_esEs15(zwu402, zwu602, fb)
new_lt23(zwu137, zwu140, ty_Float) → new_lt14(zwu137, zwu140)
new_ltEs18(Right(zwu730), Left(zwu740), cff, cec) → False
new_esEs38(zwu4000, zwu6000, ty_Bool) → new_esEs16(zwu4000, zwu6000)
new_esEs8(zwu400, zwu600, app(ty_[], bef)) → new_esEs15(zwu400, zwu600, bef)
new_esEs27(zwu149, zwu151, app(ty_Ratio, bad)) → new_esEs24(zwu149, zwu151, bad)
new_esEs29(zwu731, zwu741, app(app(app(ty_@3, cae), caf), cag)) → new_esEs13(zwu731, zwu741, cae, caf, cag)
new_esEs9(zwu401, zwu601, app(ty_Maybe, bfg)) → new_esEs14(zwu401, zwu601, bfg)
new_esEs40(zwu4002, zwu6002, ty_Int) → new_esEs12(zwu4002, zwu6002)
new_esEs27(zwu149, zwu151, app(app(ty_Either, bbd), bbe)) → new_esEs22(zwu149, zwu151, bbd, bbe)
new_ltEs4(zwu150, zwu152, app(app(ty_Either, bcf), bcg)) → new_ltEs18(zwu150, zwu152, bcf, bcg)
new_esEs21(GT, GT) → True
new_ltEs22(zwu138, zwu141, ty_Float) → new_ltEs14(zwu138, zwu141)
new_pePe(False, zwu260) → zwu260
new_esEs22(Right(zwu4000), Right(zwu6000), fag, ty_Integer) → new_esEs25(zwu4000, zwu6000)
new_esEs9(zwu401, zwu601, app(app(ty_@2, bga), bgb)) → new_esEs17(zwu401, zwu601, bga, bgb)
new_esEs27(zwu149, zwu151, app(app(app(ty_@3, baf), bag), bah)) → new_esEs13(zwu149, zwu151, baf, bag, bah)
new_esEs14(Just(zwu4000), Just(zwu6000), app(app(ty_Either, ffc), ffd)) → new_esEs22(zwu4000, zwu6000, ffc, ffd)
new_esEs7(zwu402, zwu602, ty_Int) → new_esEs12(zwu402, zwu602)
new_lt5(zwu149, zwu151, app(ty_[], bba)) → new_lt16(zwu149, zwu151, bba)
new_esEs40(zwu4002, zwu6002, app(app(ty_@2, gag), gah)) → new_esEs17(zwu4002, zwu6002, gag, gah)
new_gt(zwu24, zwu19, ty_Double) → new_esEs41(new_compare11(zwu24, zwu19))
new_esEs5(zwu400, zwu600, ty_@0) → new_esEs20(zwu400, zwu600)
new_lt20(zwu730, zwu740, app(app(app(ty_@3, bhc), bhd), bhe)) → new_lt13(zwu730, zwu740, bhc, bhd, bhe)
new_esEs31(zwu136, zwu139, app(app(ty_Either, ddb), ddc)) → new_esEs22(zwu136, zwu139, ddb, ddc)
new_esEs26(EQ) → False
new_esEs28(zwu730, zwu740, ty_@0) → new_esEs20(zwu730, zwu740)
new_esEs35(zwu4000, zwu6000, ty_Bool) → new_esEs16(zwu4000, zwu6000)
new_ltEs22(zwu138, zwu141, app(app(ty_Either, dff), dfg)) → new_ltEs18(zwu138, zwu141, dff, dfg)
new_esEs35(zwu4000, zwu6000, app(app(ty_Either, fdb), fdc)) → new_esEs22(zwu4000, zwu6000, fdb, fdc)
new_compare113(zwu248, zwu249, zwu250, zwu251, True, efc, efd) → LT
new_esEs22(Left(zwu4000), Left(zwu6000), app(ty_Ratio, faf), ehg) → new_esEs24(zwu4000, zwu6000, faf)
new_lt6(zwu40, zwu60) → new_esEs26(new_compare8(zwu40, zwu60))
new_esEs22(Right(zwu4000), Right(zwu6000), fag, ty_Int) → new_esEs12(zwu4000, zwu6000)
new_ltEs19(zwu732, zwu742, ty_Bool) → new_ltEs6(zwu732, zwu742)
new_esEs40(zwu4002, zwu6002, app(app(app(ty_@3, gab), gac), gad)) → new_esEs13(zwu4002, zwu6002, gab, gac, gad)
new_ltEs18(Right(zwu730), Right(zwu740), cff, app(app(ty_Either, cgg), cgh)) → new_ltEs18(zwu730, zwu740, cgg, cgh)
new_ltEs9(Just(zwu730), Just(zwu740), ty_Char) → new_ltEs11(zwu730, zwu740)
new_lt21(zwu730, zwu740, app(app(ty_@2, daa), dab)) → new_lt17(zwu730, zwu740, daa, dab)
new_esEs31(zwu136, zwu139, app(app(ty_@2, dch), dda)) → new_esEs17(zwu136, zwu139, dch, dda)
new_esEs8(zwu400, zwu600, app(app(ty_Either, bfa), bfb)) → new_esEs22(zwu400, zwu600, bfa, bfb)
new_esEs40(zwu4002, zwu6002, ty_Integer) → new_esEs25(zwu4002, zwu6002)
new_ltEs18(Right(zwu730), Right(zwu740), cff, ty_Bool) → new_ltEs6(zwu730, zwu740)
new_esEs39(zwu4001, zwu6001, app(ty_[], fhd)) → new_esEs15(zwu4001, zwu6001, fhd)
new_compare0([], [], gb) → EQ
new_pePe(True, zwu260) → True
new_primEqNat0(Zero, Zero) → True
new_ltEs24(zwu118, zwu119, ty_@0) → new_ltEs12(zwu118, zwu119)
new_esEs29(zwu731, zwu741, ty_Integer) → new_esEs25(zwu731, zwu741)
new_ltEs21(zwu731, zwu741, app(app(app(ty_@3, dag), dah), dba)) → new_ltEs13(zwu731, zwu741, dag, dah, dba)
new_esEs27(zwu149, zwu151, ty_Float) → new_esEs23(zwu149, zwu151)
new_lt20(zwu730, zwu740, app(ty_Ratio, bha)) → new_lt8(zwu730, zwu740, bha)
new_ltEs21(zwu731, zwu741, app(ty_Maybe, daf)) → new_ltEs9(zwu731, zwu741, daf)
new_lt20(zwu730, zwu740, ty_Bool) → new_lt7(zwu730, zwu740)
new_ltEs4(zwu150, zwu152, ty_Bool) → new_ltEs6(zwu150, zwu152)
new_ltEs23(zwu73, zwu74, app(ty_Ratio, eef)) → new_ltEs7(zwu73, zwu74, eef)
new_esEs6(zwu401, zwu601, ty_Char) → new_esEs18(zwu401, zwu601)
new_compare110(zwu179, zwu180, False, eeg, eeh) → GT
new_esEs38(zwu4000, zwu6000, ty_Char) → new_esEs18(zwu4000, zwu6000)
new_ltEs19(zwu732, zwu742, ty_@0) → new_ltEs12(zwu732, zwu742)
new_esEs34(zwu4001, zwu6001, ty_Double) → new_esEs19(zwu4001, zwu6001)
new_esEs30(zwu730, zwu740, app(ty_Ratio, chc)) → new_esEs24(zwu730, zwu740, chc)
new_esEs33(zwu4000, zwu6000, app(ty_[], eab)) → new_esEs15(zwu4000, zwu6000, eab)
new_esEs35(zwu4000, zwu6000, ty_Ordering) → new_esEs21(zwu4000, zwu6000)
new_esEs27(zwu149, zwu151, ty_@0) → new_esEs20(zwu149, zwu151)
new_lt23(zwu137, zwu140, ty_Double) → new_lt9(zwu137, zwu140)
new_ltEs5(LT, LT) → True
new_lt24(zwu40, zwu60, ty_Bool) → new_lt7(zwu40, zwu60)
new_compare8(LT, EQ) → LT
new_ltEs20(zwu111, zwu112, ty_Int) → new_ltEs15(zwu111, zwu112)
new_primEqInt(Neg(Succ(zwu40000)), Neg(Succ(zwu60000))) → new_primEqNat0(zwu40000, zwu60000)
new_compare7(zwu400, zwu600, ty_Ordering) → new_compare8(zwu400, zwu600)
new_compare115(zwu189, zwu190, True, fde, fdf) → LT
new_ltEs22(zwu138, zwu141, app(ty_Ratio, def)) → new_ltEs7(zwu138, zwu141, def)
new_esEs9(zwu401, zwu601, app(app(app(ty_@3, bfd), bfe), bff)) → new_esEs13(zwu401, zwu601, bfd, bfe, bff)
new_esEs35(zwu4000, zwu6000, ty_Double) → new_esEs19(zwu4000, zwu6000)
new_esEs10(zwu400, zwu600, ty_Integer) → new_esEs25(zwu400, zwu600)
new_esEs40(zwu4002, zwu6002, app(ty_Ratio, gbc)) → new_esEs24(zwu4002, zwu6002, gbc)
new_esEs11(zwu400, zwu600, ty_Int) → new_esEs12(zwu400, zwu600)
new_esEs32(zwu137, zwu140, ty_Integer) → new_esEs25(zwu137, zwu140)
new_esEs30(zwu730, zwu740, ty_Integer) → new_esEs25(zwu730, zwu740)
new_gt(zwu24, zwu19, ty_Integer) → new_esEs41(new_compare12(zwu24, zwu19))
new_primEqInt(Neg(Zero), Neg(Zero)) → True
new_ltEs21(zwu731, zwu741, app(ty_Ratio, dae)) → new_ltEs7(zwu731, zwu741, dae)
new_esEs9(zwu401, zwu601, ty_Int) → new_esEs12(zwu401, zwu601)
new_esEs9(zwu401, zwu601, app(ty_Ratio, bge)) → new_esEs24(zwu401, zwu601, bge)
new_esEs34(zwu4001, zwu6001, app(ty_[], ebd)) → new_esEs15(zwu4001, zwu6001, ebd)
new_compare9(False, False) → EQ
new_ltEs18(Left(zwu730), Right(zwu740), cff, cec) → True
new_esEs30(zwu730, zwu740, ty_Bool) → new_esEs16(zwu730, zwu740)
new_lt21(zwu730, zwu740, ty_Float) → new_lt14(zwu730, zwu740)
new_esEs33(zwu4000, zwu6000, app(app(ty_Either, eae), eaf)) → new_esEs22(zwu4000, zwu6000, eae, eaf)
new_esEs8(zwu400, zwu600, ty_@0) → new_esEs20(zwu400, zwu600)
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_ltEs18(Left(zwu730), Left(zwu740), ty_Double, cec) → new_ltEs8(zwu730, zwu740)
new_ltEs24(zwu118, zwu119, ty_Char) → new_ltEs11(zwu118, zwu119)
new_lt22(zwu136, zwu139, app(app(app(ty_@3, dcd), dce), dcf)) → new_lt13(zwu136, zwu139, dcd, dce, dcf)
new_compare18(Right(zwu400), Left(zwu600), hh, baa) → GT
new_esEs14(Just(zwu4000), Just(zwu6000), ty_Char) → new_esEs18(zwu4000, zwu6000)
new_esEs38(zwu4000, zwu6000, app(app(ty_Either, fge), fgf)) → new_esEs22(zwu4000, zwu6000, fge, fgf)
new_esEs9(zwu401, zwu601, ty_Integer) → new_esEs25(zwu401, zwu601)
new_primEqInt(Pos(Succ(zwu40000)), Pos(Succ(zwu60000))) → new_primEqNat0(zwu40000, zwu60000)
new_lt10(zwu40, zwu60) → new_esEs26(new_compare12(zwu40, zwu60))
new_esEs34(zwu4001, zwu6001, ty_Char) → new_esEs18(zwu4001, zwu6001)
new_esEs8(zwu400, zwu600, app(ty_Ratio, bfc)) → new_esEs24(zwu400, zwu600, bfc)
new_lt21(zwu730, zwu740, ty_Integer) → new_lt10(zwu730, zwu740)
new_esEs38(zwu4000, zwu6000, ty_Ordering) → new_esEs21(zwu4000, zwu6000)
new_esEs5(zwu400, zwu600, app(ty_[], ce)) → new_esEs15(zwu400, zwu600, ce)
new_esEs34(zwu4001, zwu6001, app(app(ty_@2, ebe), ebf)) → new_esEs17(zwu4001, zwu6001, ebe, ebf)
new_esEs22(Left(zwu4000), Left(zwu6000), ty_Bool, ehg) → new_esEs16(zwu4000, zwu6000)
new_primEqNat0(Succ(zwu40000), Succ(zwu60000)) → new_primEqNat0(zwu40000, zwu60000)
new_esEs22(Right(zwu4000), Right(zwu6000), fag, ty_@0) → new_esEs20(zwu4000, zwu6000)
new_lt23(zwu137, zwu140, app(app(app(ty_@3, ddf), ddg), ddh)) → new_lt13(zwu137, zwu140, ddf, ddg, ddh)
new_compare8(EQ, EQ) → EQ
new_lt21(zwu730, zwu740, ty_Int) → new_lt15(zwu730, zwu740)
new_lt21(zwu730, zwu740, ty_@0) → new_lt12(zwu730, zwu740)
new_gt(zwu24, zwu19, ty_Ordering) → new_esEs41(new_compare8(zwu24, zwu19))
new_esEs22(Left(zwu4000), Left(zwu6000), ty_Float, ehg) → new_esEs23(zwu4000, zwu6000)
new_esEs22(Right(zwu4000), Right(zwu6000), fag, app(app(ty_@2, fbe), fbf)) → new_esEs17(zwu4000, zwu6000, fbe, fbf)
new_esEs38(zwu4000, zwu6000, app(ty_Maybe, fga)) → new_esEs14(zwu4000, zwu6000, fga)
new_compare10(:%(zwu400, zwu401), :%(zwu600, zwu601), ty_Integer) → new_compare12(new_sr0(zwu400, zwu601), new_sr0(zwu600, zwu401))
new_esEs34(zwu4001, zwu6001, ty_@0) → new_esEs20(zwu4001, zwu6001)
new_esEs8(zwu400, zwu600, ty_Ordering) → new_esEs21(zwu400, zwu600)
new_esEs5(zwu400, zwu600, ty_Char) → new_esEs18(zwu400, zwu600)
new_compare7(zwu400, zwu600, ty_@0) → new_compare14(zwu400, zwu600)
new_ltEs8(zwu73, zwu74) → new_fsEs(new_compare11(zwu73, zwu74))
new_ltEs4(zwu150, zwu152, ty_Double) → new_ltEs8(zwu150, zwu152)
new_lt22(zwu136, zwu139, ty_Char) → new_lt11(zwu136, zwu139)
new_esEs19(Double(zwu4000, zwu4001), Double(zwu6000, zwu6001)) → new_esEs12(new_sr(zwu4000, zwu6000), new_sr(zwu4001, zwu6001))
new_ltEs9(Just(zwu730), Just(zwu740), app(ty_Maybe, dgb)) → new_ltEs9(zwu730, zwu740, dgb)
new_esEs27(zwu149, zwu151, ty_Ordering) → new_esEs21(zwu149, zwu151)
new_esEs30(zwu730, zwu740, ty_@0) → new_esEs20(zwu730, zwu740)
new_esEs10(zwu400, zwu600, app(app(app(ty_@3, ecb), ecc), ecd)) → new_esEs13(zwu400, zwu600, ecb, ecc, ecd)
new_esEs6(zwu401, zwu601, ty_@0) → new_esEs20(zwu401, zwu601)
new_esEs6(zwu401, zwu601, ty_Int) → new_esEs12(zwu401, zwu601)
new_lt16(zwu40, zwu60, gb) → new_esEs26(new_compare0(zwu40, zwu60, gb))
new_lt23(zwu137, zwu140, ty_Integer) → new_lt10(zwu137, zwu140)
new_esEs40(zwu4002, zwu6002, ty_Char) → new_esEs18(zwu4002, zwu6002)
new_compare26(zwu149, zwu150, zwu151, zwu152, False, bab, bac) → new_compare19(zwu149, zwu150, zwu151, zwu152, new_lt5(zwu149, zwu151, bab), new_asAs(new_esEs27(zwu149, zwu151, bab), new_ltEs4(zwu150, zwu152, bac)), bab, bac)
new_esEs10(zwu400, zwu600, ty_Char) → new_esEs18(zwu400, zwu600)
new_esEs7(zwu402, zwu602, app(app(ty_Either, ff), fg)) → new_esEs22(zwu402, zwu602, ff, fg)
new_esEs5(zwu400, zwu600, ty_Int) → new_esEs12(zwu400, zwu600)
new_lt13(zwu40, zwu60, bf, bg, bh) → new_esEs26(new_compare5(zwu40, zwu60, bf, bg, bh))
new_esEs24(:%(zwu4000, zwu4001), :%(zwu6000, zwu6001), fdg) → new_asAs(new_esEs36(zwu4000, zwu6000, fdg), new_esEs37(zwu4001, zwu6001, fdg))
new_esEs6(zwu401, zwu601, ty_Bool) → new_esEs16(zwu401, zwu601)
new_lt23(zwu137, zwu140, app(ty_Maybe, dde)) → new_lt4(zwu137, zwu140, dde)
new_ltEs24(zwu118, zwu119, ty_Integer) → new_ltEs10(zwu118, zwu119)
new_lt11(zwu40, zwu60) → new_esEs26(new_compare13(zwu40, zwu60))
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primEqInt(Neg(Zero), Pos(Succ(zwu60000))) → False
new_primEqInt(Pos(Zero), Neg(Succ(zwu60000))) → False
new_ltEs9(Just(zwu730), Nothing, dfh) → False
new_lt24(zwu40, zwu60, ty_Integer) → new_lt10(zwu40, zwu60)
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCompAux00(zwu94, EQ) → zwu94
new_esEs22(Left(zwu4000), Left(zwu6000), ty_Integer, ehg) → new_esEs25(zwu4000, zwu6000)
new_esEs38(zwu4000, zwu6000, app(app(ty_@2, fgc), fgd)) → new_esEs17(zwu4000, zwu6000, fgc, fgd)
new_ltEs18(Left(zwu730), Left(zwu740), ty_Integer, cec) → new_ltEs10(zwu730, zwu740)
new_esEs10(zwu400, zwu600, ty_Double) → new_esEs19(zwu400, zwu600)
new_esEs31(zwu136, zwu139, ty_Int) → new_esEs12(zwu136, zwu139)
new_ltEs17(@2(zwu730, zwu731), @2(zwu740, zwu741), cha, chb) → new_pePe(new_lt21(zwu730, zwu740, cha), new_asAs(new_esEs30(zwu730, zwu740, cha), new_ltEs21(zwu731, zwu741, chb)))
new_lt15(zwu40, zwu60) → new_esEs26(new_compare16(zwu40, zwu60))
new_esEs7(zwu402, zwu602, ty_Double) → new_esEs19(zwu402, zwu602)
new_esEs38(zwu4000, zwu6000, ty_Double) → new_esEs19(zwu4000, zwu6000)
new_esEs5(zwu400, zwu600, ty_Ordering) → new_esEs21(zwu400, zwu600)
new_compare29(zwu73, zwu74, False, efa) → new_compare112(zwu73, zwu74, new_ltEs23(zwu73, zwu74, efa), efa)
new_esEs11(zwu400, zwu600, ty_@0) → new_esEs20(zwu400, zwu600)
new_ltEs9(Just(zwu730), Just(zwu740), ty_Bool) → new_ltEs6(zwu730, zwu740)
new_esEs4(zwu400, zwu600, ty_Int) → new_esEs12(zwu400, zwu600)
new_esEs28(zwu730, zwu740, ty_Ordering) → new_esEs21(zwu730, zwu740)
new_not(False) → True
new_ltEs18(Right(zwu730), Right(zwu740), cff, ty_Float) → new_ltEs14(zwu730, zwu740)
new_lt21(zwu730, zwu740, ty_Double) → new_lt9(zwu730, zwu740)
new_esEs8(zwu400, zwu600, app(ty_Maybe, bee)) → new_esEs14(zwu400, zwu600, bee)
new_lt19(zwu731, zwu741, ty_Int) → new_lt15(zwu731, zwu741)
new_lt5(zwu149, zwu151, ty_Integer) → new_lt10(zwu149, zwu151)
new_esEs14(Just(zwu4000), Just(zwu6000), ty_Double) → new_esEs19(zwu4000, zwu6000)
new_esEs28(zwu730, zwu740, app(app(app(ty_@3, bhc), bhd), bhe)) → new_esEs13(zwu730, zwu740, bhc, bhd, bhe)
new_esEs8(zwu400, zwu600, app(app(app(ty_@3, beb), bec), bed)) → new_esEs13(zwu400, zwu600, beb, bec, bed)
new_compare17(@2(zwu400, zwu401), @2(zwu600, zwu601), hf, hg) → new_compare26(zwu400, zwu401, zwu600, zwu601, new_asAs(new_esEs8(zwu400, zwu600, hf), new_esEs9(zwu401, zwu601, hg)), hf, hg)
new_lt4(zwu40, zwu60, ga) → new_esEs26(new_compare6(zwu40, zwu60, ga))
new_esEs35(zwu4000, zwu6000, ty_Int) → new_esEs12(zwu4000, zwu6000)
new_ltEs4(zwu150, zwu152, app(app(app(ty_@3, bbh), bca), bcb)) → new_ltEs13(zwu150, zwu152, bbh, bca, bcb)
new_esEs22(Right(zwu4000), Right(zwu6000), fag, ty_Float) → new_esEs23(zwu4000, zwu6000)
new_esEs22(Left(zwu4000), Left(zwu6000), app(app(ty_Either, fad), fae), ehg) → new_esEs22(zwu4000, zwu6000, fad, fae)
new_ltEs18(Left(zwu730), Left(zwu740), ty_Ordering, cec) → new_ltEs5(zwu730, zwu740)
new_esEs30(zwu730, zwu740, app(app(ty_@2, daa), dab)) → new_esEs17(zwu730, zwu740, daa, dab)
new_compare0(:(zwu400, zwu401), [], gb) → GT
new_esEs32(zwu137, zwu140, app(ty_[], dea)) → new_esEs15(zwu137, zwu140, dea)
new_lt20(zwu730, zwu740, ty_Double) → new_lt9(zwu730, zwu740)
new_esEs35(zwu4000, zwu6000, app(ty_Ratio, fdd)) → new_esEs24(zwu4000, zwu6000, fdd)
new_lt19(zwu731, zwu741, ty_Float) → new_lt14(zwu731, zwu741)
new_lt22(zwu136, zwu139, ty_Float) → new_lt14(zwu136, zwu139)
new_ltEs18(Right(zwu730), Right(zwu740), cff, ty_Int) → new_ltEs15(zwu730, zwu740)
new_ltEs19(zwu732, zwu742, app(app(ty_Either, cce), ccf)) → new_ltEs18(zwu732, zwu742, cce, ccf)
new_esEs4(zwu400, zwu600, ty_Double) → new_esEs19(zwu400, zwu600)
new_esEs39(zwu4001, zwu6001, ty_Integer) → new_esEs25(zwu4001, zwu6001)
new_ltEs19(zwu732, zwu742, app(ty_[], ccb)) → new_ltEs16(zwu732, zwu742, ccb)
new_esEs22(Right(zwu4000), Right(zwu6000), fag, ty_Ordering) → new_esEs21(zwu4000, zwu6000)
new_lt20(zwu730, zwu740, ty_Integer) → new_lt10(zwu730, zwu740)
new_ltEs24(zwu118, zwu119, ty_Bool) → new_ltEs6(zwu118, zwu119)
new_esEs34(zwu4001, zwu6001, ty_Float) → new_esEs23(zwu4001, zwu6001)
new_esEs6(zwu401, zwu601, ty_Double) → new_esEs19(zwu401, zwu601)
new_ltEs23(zwu73, zwu74, app(ty_[], dhc)) → new_ltEs16(zwu73, zwu74, dhc)
new_esEs39(zwu4001, zwu6001, app(app(app(ty_@3, fgh), fha), fhb)) → new_esEs13(zwu4001, zwu6001, fgh, fha, fhb)
new_primMulInt(Neg(zwu4000), Neg(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_lt24(zwu40, zwu60, ty_Ordering) → new_lt6(zwu40, zwu60)
new_ltEs19(zwu732, zwu742, ty_Integer) → new_ltEs10(zwu732, zwu742)
new_ltEs9(Just(zwu730), Just(zwu740), ty_@0) → new_ltEs12(zwu730, zwu740)
new_esEs39(zwu4001, zwu6001, ty_Ordering) → new_esEs21(zwu4001, zwu6001)
new_primEqNat0(Zero, Succ(zwu60000)) → False
new_primEqNat0(Succ(zwu40000), Zero) → False
new_compare113(zwu248, zwu249, zwu250, zwu251, False, efc, efd) → GT
new_ltEs9(Just(zwu730), Just(zwu740), app(app(app(ty_@3, dgc), dgd), dge)) → new_ltEs13(zwu730, zwu740, dgc, dgd, dge)
new_lt5(zwu149, zwu151, ty_@0) → new_lt12(zwu149, zwu151)
new_ltEs9(Just(zwu730), Just(zwu740), ty_Integer) → new_ltEs10(zwu730, zwu740)
new_lt20(zwu730, zwu740, app(app(ty_Either, caa), cab)) → new_lt18(zwu730, zwu740, caa, cab)
new_compare8(LT, LT) → EQ
new_ltEs18(Left(zwu730), Left(zwu740), app(ty_[], cfa), cec) → new_ltEs16(zwu730, zwu740, cfa)
new_esEs11(zwu400, zwu600, app(app(ty_@2, eea), eeb)) → new_esEs17(zwu400, zwu600, eea, eeb)
new_ltEs22(zwu138, zwu141, ty_Double) → new_ltEs8(zwu138, zwu141)
new_compare8(EQ, GT) → LT
new_ltEs21(zwu731, zwu741, ty_Integer) → new_ltEs10(zwu731, zwu741)
new_gt(zwu24, zwu19, app(app(ty_Either, bdh), bea)) → new_esEs41(new_compare18(zwu24, zwu19, bdh, bea))
new_compare7(zwu400, zwu600, ty_Integer) → new_compare12(zwu400, zwu600)
new_lt19(zwu731, zwu741, ty_@0) → new_lt12(zwu731, zwu741)
new_esEs13(@3(zwu4000, zwu4001, zwu4002), @3(zwu6000, zwu6001, zwu6002), fdh, fea, feb) → new_asAs(new_esEs38(zwu4000, zwu6000, fdh), new_asAs(new_esEs39(zwu4001, zwu6001, fea), new_esEs40(zwu4002, zwu6002, feb)))
new_esEs10(zwu400, zwu600, app(ty_Ratio, edc)) → new_esEs24(zwu400, zwu600, edc)
new_esEs6(zwu401, zwu601, app(ty_[], dh)) → new_esEs15(zwu401, zwu601, dh)
new_esEs27(zwu149, zwu151, ty_Bool) → new_esEs16(zwu149, zwu151)
new_lt23(zwu137, zwu140, app(ty_[], dea)) → new_lt16(zwu137, zwu140, dea)
new_esEs22(Right(zwu4000), Right(zwu6000), fag, app(ty_Maybe, fbc)) → new_esEs14(zwu4000, zwu6000, fbc)
new_compare18(Right(zwu400), Right(zwu600), hh, baa) → new_compare28(zwu400, zwu600, new_esEs11(zwu400, zwu600, baa), hh, baa)
new_esEs33(zwu4000, zwu6000, ty_Ordering) → new_esEs21(zwu4000, zwu6000)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_esEs10(zwu400, zwu600, ty_Ordering) → new_esEs21(zwu400, zwu600)
new_esEs30(zwu730, zwu740, ty_Char) → new_esEs18(zwu730, zwu740)
new_esEs12(zwu400, zwu600) → new_primEqInt(zwu400, zwu600)
new_esEs4(zwu400, zwu600, app(app(ty_Either, fag), ehg)) → new_esEs22(zwu400, zwu600, fag, ehg)
new_ltEs22(zwu138, zwu141, ty_@0) → new_ltEs12(zwu138, zwu141)
new_compare7(zwu400, zwu600, app(ty_Ratio, gc)) → new_compare10(zwu400, zwu600, gc)
new_lt5(zwu149, zwu151, ty_Float) → new_lt14(zwu149, zwu151)
new_esEs28(zwu730, zwu740, app(app(ty_@2, bhg), bhh)) → new_esEs17(zwu730, zwu740, bhg, bhh)
new_ltEs19(zwu732, zwu742, ty_Double) → new_ltEs8(zwu732, zwu742)
new_esEs15([], :(zwu6000, zwu6001), fcb) → False
new_esEs15(:(zwu4000, zwu4001), [], fcb) → False
new_ltEs24(zwu118, zwu119, app(ty_Maybe, egc)) → new_ltEs9(zwu118, zwu119, egc)
new_primCompAux0(zwu400, zwu600, zwu57, gb) → new_primCompAux00(zwu57, new_compare7(zwu400, zwu600, gb))
new_esEs39(zwu4001, zwu6001, ty_Char) → new_esEs18(zwu4001, zwu6001)
new_ltEs20(zwu111, zwu112, app(ty_[], cdf)) → new_ltEs16(zwu111, zwu112, cdf)
new_esEs31(zwu136, zwu139, app(app(app(ty_@3, dcd), dce), dcf)) → new_esEs13(zwu136, zwu139, dcd, dce, dcf)
new_ltEs18(Right(zwu730), Right(zwu740), cff, app(app(app(ty_@3, cga), cgb), cgc)) → new_ltEs13(zwu730, zwu740, cga, cgb, cgc)
new_esEs27(zwu149, zwu151, app(ty_Maybe, bae)) → new_esEs14(zwu149, zwu151, bae)
new_ltEs9(Just(zwu730), Just(zwu740), app(app(ty_@2, dgg), dgh)) → new_ltEs17(zwu730, zwu740, dgg, dgh)
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs34(zwu4001, zwu6001, ty_Int) → new_esEs12(zwu4001, zwu6001)
new_lt17(zwu40, zwu60, hf, hg) → new_esEs26(new_compare17(zwu40, zwu60, hf, hg))
new_ltEs22(zwu138, zwu141, app(ty_[], dfc)) → new_ltEs16(zwu138, zwu141, dfc)
new_ltEs4(zwu150, zwu152, ty_Integer) → new_ltEs10(zwu150, zwu152)
new_compare6(Just(zwu400), Nothing, ga) → GT
new_lt21(zwu730, zwu740, ty_Char) → new_lt11(zwu730, zwu740)
new_esEs34(zwu4001, zwu6001, app(ty_Ratio, eca)) → new_esEs24(zwu4001, zwu6001, eca)
new_esEs14(Nothing, Nothing, fec) → True
new_esEs38(zwu4000, zwu6000, ty_Int) → new_esEs12(zwu4000, zwu6000)
new_asAs(False, zwu174) → False
new_esEs33(zwu4000, zwu6000, ty_Float) → new_esEs23(zwu4000, zwu6000)
new_esEs6(zwu401, zwu601, app(app(ty_Either, ec), ed)) → new_esEs22(zwu401, zwu601, ec, ed)
new_esEs14(Just(zwu4000), Just(zwu6000), ty_Integer) → new_esEs25(zwu4000, zwu6000)
new_primMulInt(Neg(zwu4000), Pos(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_compare16(zwu40, zwu60) → new_primCmpInt(zwu40, zwu60)
new_ltEs19(zwu732, zwu742, ty_Float) → new_ltEs14(zwu732, zwu742)
new_ltEs18(Right(zwu730), Right(zwu740), cff, ty_Ordering) → new_ltEs5(zwu730, zwu740)
new_ltEs18(Right(zwu730), Right(zwu740), cff, ty_Double) → new_ltEs8(zwu730, zwu740)
new_esEs37(zwu4001, zwu6001, ty_Integer) → new_esEs25(zwu4001, zwu6001)
new_lt21(zwu730, zwu740, app(ty_Maybe, chd)) → new_lt4(zwu730, zwu740, chd)
new_esEs10(zwu400, zwu600, ty_@0) → new_esEs20(zwu400, zwu600)
new_esEs36(zwu4000, zwu6000, ty_Int) → new_esEs12(zwu4000, zwu6000)
new_esEs33(zwu4000, zwu6000, app(ty_Maybe, eaa)) → new_esEs14(zwu4000, zwu6000, eaa)
new_esEs33(zwu4000, zwu6000, app(ty_Ratio, eag)) → new_esEs24(zwu4000, zwu6000, eag)
new_esEs34(zwu4001, zwu6001, ty_Bool) → new_esEs16(zwu4001, zwu6001)
new_esEs23(Float(zwu4000, zwu4001), Float(zwu6000, zwu6001)) → new_esEs12(new_sr(zwu4000, zwu6000), new_sr(zwu4001, zwu6001))
new_ltEs4(zwu150, zwu152, app(ty_[], bcc)) → new_ltEs16(zwu150, zwu152, bcc)
new_compare114(zwu233, zwu234, zwu235, zwu236, zwu237, zwu238, True, efe, eff, efg) → LT
new_esEs10(zwu400, zwu600, ty_Bool) → new_esEs16(zwu400, zwu600)
new_ltEs4(zwu150, zwu152, ty_Int) → new_ltEs15(zwu150, zwu152)
new_esEs39(zwu4001, zwu6001, app(ty_Ratio, gaa)) → new_esEs24(zwu4001, zwu6001, gaa)
new_esEs22(Left(zwu4000), Left(zwu6000), app(app(ty_@2, fab), fac), ehg) → new_esEs17(zwu4000, zwu6000, fab, fac)
new_lt19(zwu731, zwu741, app(app(app(ty_@3, cae), caf), cag)) → new_lt13(zwu731, zwu741, cae, caf, cag)
new_compare28(zwu118, zwu119, False, efh, ega) → new_compare115(zwu118, zwu119, new_ltEs24(zwu118, zwu119, ega), efh, ega)
new_esEs14(Just(zwu4000), Just(zwu6000), app(app(app(ty_@3, fed), fee), fef)) → new_esEs13(zwu4000, zwu6000, fed, fee, fef)
new_esEs40(zwu4002, zwu6002, ty_Bool) → new_esEs16(zwu4002, zwu6002)
new_esEs11(zwu400, zwu600, ty_Double) → new_esEs19(zwu400, zwu600)
new_esEs30(zwu730, zwu740, app(app(ty_Either, dac), dad)) → new_esEs22(zwu730, zwu740, dac, dad)
new_esEs27(zwu149, zwu151, ty_Integer) → new_esEs25(zwu149, zwu151)
new_esEs21(GT, LT) → False
new_esEs21(LT, GT) → False
new_esEs8(zwu400, zwu600, app(app(ty_@2, beg), beh)) → new_esEs17(zwu400, zwu600, beg, beh)
new_ltEs18(Left(zwu730), Left(zwu740), ty_Bool, cec) → new_ltEs6(zwu730, zwu740)
new_esEs41(GT) → True
new_esEs40(zwu4002, zwu6002, ty_Double) → new_esEs19(zwu4002, zwu6002)
new_esEs6(zwu401, zwu601, app(ty_Maybe, dg)) → new_esEs14(zwu401, zwu601, dg)
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_esEs22(Right(zwu4000), Right(zwu6000), fag, ty_Double) → new_esEs19(zwu4000, zwu6000)
new_compare9(True, True) → EQ
new_esEs31(zwu136, zwu139, ty_Char) → new_esEs18(zwu136, zwu139)
new_ltEs9(Just(zwu730), Just(zwu740), app(app(ty_Either, dha), dhb)) → new_ltEs18(zwu730, zwu740, dha, dhb)
new_lt24(zwu40, zwu60, ty_Int) → new_lt15(zwu40, zwu60)
new_lt19(zwu731, zwu741, ty_Char) → new_lt11(zwu731, zwu741)
new_esEs28(zwu730, zwu740, ty_Int) → new_esEs12(zwu730, zwu740)
new_compare0([], :(zwu600, zwu601), gb) → LT
new_esEs35(zwu4000, zwu6000, ty_Integer) → new_esEs25(zwu4000, zwu6000)
new_esEs7(zwu402, zwu602, ty_Char) → new_esEs18(zwu402, zwu602)
new_esEs6(zwu401, zwu601, app(ty_Ratio, ee)) → new_esEs24(zwu401, zwu601, ee)
new_esEs39(zwu4001, zwu6001, app(ty_Maybe, fhc)) → new_esEs14(zwu4001, zwu6001, fhc)
new_esEs26(LT) → True
new_ltEs4(zwu150, zwu152, app(ty_Ratio, bbf)) → new_ltEs7(zwu150, zwu152, bbf)
new_asAs(True, zwu174) → zwu174
new_ltEs22(zwu138, zwu141, ty_Bool) → new_ltEs6(zwu138, zwu141)
new_ltEs19(zwu732, zwu742, app(ty_Ratio, cbe)) → new_ltEs7(zwu732, zwu742, cbe)
new_ltEs5(GT, GT) → True
new_esEs6(zwu401, zwu601, ty_Integer) → new_esEs25(zwu401, zwu601)
new_esEs32(zwu137, zwu140, ty_Double) → new_esEs19(zwu137, zwu140)
new_esEs4(zwu400, zwu600, ty_Char) → new_esEs18(zwu400, zwu600)
new_ltEs18(Left(zwu730), Left(zwu740), ty_Char, cec) → new_ltEs11(zwu730, zwu740)
new_esEs22(Right(zwu4000), Left(zwu6000), fag, ehg) → False
new_esEs22(Left(zwu4000), Right(zwu6000), fag, ehg) → False
new_esEs29(zwu731, zwu741, app(ty_[], cah)) → new_esEs15(zwu731, zwu741, cah)
new_ltEs21(zwu731, zwu741, ty_Int) → new_ltEs15(zwu731, zwu741)
new_ltEs6(False, False) → True
new_esEs5(zwu400, zwu600, app(app(ty_Either, da), db)) → new_esEs22(zwu400, zwu600, da, db)
new_compare7(zwu400, zwu600, ty_Bool) → new_compare9(zwu400, zwu600)
new_compare27(zwu111, zwu112, False, ccg, cch) → new_compare110(zwu111, zwu112, new_ltEs20(zwu111, zwu112, ccg), ccg, cch)
new_esEs17(@2(zwu4000, zwu4001), @2(zwu6000, zwu6001), dhd, dhe) → new_asAs(new_esEs33(zwu4000, zwu6000, dhd), new_esEs34(zwu4001, zwu6001, dhe))
new_compare6(Nothing, Just(zwu600), ga) → LT
new_ltEs21(zwu731, zwu741, ty_Char) → new_ltEs11(zwu731, zwu741)
new_lt19(zwu731, zwu741, app(ty_Ratio, cac)) → new_lt8(zwu731, zwu741, cac)
new_gt(zwu24, zwu19, ty_Float) → new_esEs41(new_compare15(zwu24, zwu19))
new_esEs30(zwu730, zwu740, app(ty_[], chh)) → new_esEs15(zwu730, zwu740, chh)
new_compare8(GT, LT) → GT
new_lt5(zwu149, zwu151, app(ty_Maybe, bae)) → new_lt4(zwu149, zwu151, bae)
new_esEs8(zwu400, zwu600, ty_Double) → new_esEs19(zwu400, zwu600)
new_ltEs22(zwu138, zwu141, ty_Int) → new_ltEs15(zwu138, zwu141)
new_esEs39(zwu4001, zwu6001, ty_Int) → new_esEs12(zwu4001, zwu6001)
new_ltEs5(GT, EQ) → False
new_esEs31(zwu136, zwu139, ty_Ordering) → new_esEs21(zwu136, zwu139)
new_compare19(zwu248, zwu249, zwu250, zwu251, False, zwu253, efc, efd) → new_compare113(zwu248, zwu249, zwu250, zwu251, zwu253, efc, efd)
new_lt7(zwu40, zwu60) → new_esEs26(new_compare9(zwu40, zwu60))
new_primEqInt(Neg(Zero), Pos(Zero)) → True
new_primEqInt(Pos(Zero), Neg(Zero)) → True
new_esEs30(zwu730, zwu740, ty_Float) → new_esEs23(zwu730, zwu740)
new_not(True) → False
new_esEs27(zwu149, zwu151, ty_Double) → new_esEs19(zwu149, zwu151)
new_esEs31(zwu136, zwu139, app(ty_Ratio, dcb)) → new_esEs24(zwu136, zwu139, dcb)
new_ltEs10(zwu73, zwu74) → new_fsEs(new_compare12(zwu73, zwu74))
new_esEs32(zwu137, zwu140, app(ty_Ratio, ddd)) → new_esEs24(zwu137, zwu140, ddd)
new_compare112(zwu165, zwu166, True, efb) → LT
new_ltEs18(Left(zwu730), Left(zwu740), app(ty_Maybe, cee), cec) → new_ltEs9(zwu730, zwu740, cee)
new_lt22(zwu136, zwu139, ty_@0) → new_lt12(zwu136, zwu139)
new_esEs28(zwu730, zwu740, ty_Double) → new_esEs19(zwu730, zwu740)
new_esEs9(zwu401, zwu601, ty_@0) → new_esEs20(zwu401, zwu601)
new_esEs28(zwu730, zwu740, app(ty_[], bhf)) → new_esEs15(zwu730, zwu740, bhf)
new_esEs27(zwu149, zwu151, app(app(ty_@2, bbb), bbc)) → new_esEs17(zwu149, zwu151, bbb, bbc)
new_ltEs14(zwu73, zwu74) → new_fsEs(new_compare15(zwu73, zwu74))
new_compare7(zwu400, zwu600, app(app(app(ty_@3, ge), gf), gg)) → new_compare5(zwu400, zwu600, ge, gf, gg)
new_ltEs5(EQ, GT) → True
new_esEs33(zwu4000, zwu6000, app(app(ty_@2, eac), ead)) → new_esEs17(zwu4000, zwu6000, eac, ead)
new_lt19(zwu731, zwu741, app(app(ty_Either, cbc), cbd)) → new_lt18(zwu731, zwu741, cbc, cbd)
new_lt20(zwu730, zwu740, ty_Float) → new_lt14(zwu730, zwu740)
new_esEs4(zwu400, zwu600, app(app(app(ty_@3, fdh), fea), feb)) → new_esEs13(zwu400, zwu600, fdh, fea, feb)
new_esEs10(zwu400, zwu600, ty_Float) → new_esEs23(zwu400, zwu600)
new_ltEs23(zwu73, zwu74, ty_Int) → new_ltEs15(zwu73, zwu74)
new_primMulNat0(Zero, Zero) → Zero
new_esEs6(zwu401, zwu601, app(app(ty_@2, ea), eb)) → new_esEs17(zwu401, zwu601, ea, eb)
new_esEs32(zwu137, zwu140, app(app(ty_Either, ded), dee)) → new_esEs22(zwu137, zwu140, ded, dee)
new_compare18(Left(zwu400), Right(zwu600), hh, baa) → LT
new_ltEs15(zwu73, zwu74) → new_fsEs(new_compare16(zwu73, zwu74))
new_esEs5(zwu400, zwu600, ty_Bool) → new_esEs16(zwu400, zwu600)
new_esEs31(zwu136, zwu139, ty_Bool) → new_esEs16(zwu136, zwu139)
new_esEs4(zwu400, zwu600, app(ty_[], fcb)) → new_esEs15(zwu400, zwu600, fcb)
new_esEs29(zwu731, zwu741, ty_@0) → new_esEs20(zwu731, zwu741)
new_esEs35(zwu4000, zwu6000, app(ty_Maybe, fcf)) → new_esEs14(zwu4000, zwu6000, fcf)
new_lt19(zwu731, zwu741, ty_Ordering) → new_lt6(zwu731, zwu741)
new_lt22(zwu136, zwu139, app(app(ty_@2, dch), dda)) → new_lt17(zwu136, zwu139, dch, dda)
new_ltEs18(Left(zwu730), Left(zwu740), app(app(app(ty_@3, cef), ceg), ceh), cec) → new_ltEs13(zwu730, zwu740, cef, ceg, ceh)
new_ltEs4(zwu150, zwu152, ty_@0) → new_ltEs12(zwu150, zwu152)
new_lt21(zwu730, zwu740, app(ty_[], chh)) → new_lt16(zwu730, zwu740, chh)
new_compare7(zwu400, zwu600, ty_Double) → new_compare11(zwu400, zwu600)
new_ltEs24(zwu118, zwu119, app(app(ty_@2, egh), eha)) → new_ltEs17(zwu118, zwu119, egh, eha)
new_esEs4(zwu400, zwu600, ty_@0) → new_esEs20(zwu400, zwu600)
new_ltEs24(zwu118, zwu119, ty_Float) → new_ltEs14(zwu118, zwu119)
new_esEs35(zwu4000, zwu6000, app(app(app(ty_@3, fcc), fcd), fce)) → new_esEs13(zwu4000, zwu6000, fcc, fcd, fce)
new_ltEs20(zwu111, zwu112, app(app(ty_@2, cdg), cdh)) → new_ltEs17(zwu111, zwu112, cdg, cdh)
new_ltEs18(Left(zwu730), Left(zwu740), app(app(ty_Either, cfd), cfe), cec) → new_ltEs18(zwu730, zwu740, cfd, cfe)
new_esEs35(zwu4000, zwu6000, app(app(ty_@2, fch), fda)) → new_esEs17(zwu4000, zwu6000, fch, fda)
new_esEs10(zwu400, zwu600, app(ty_[], ecf)) → new_esEs15(zwu400, zwu600, ecf)
new_esEs36(zwu4000, zwu6000, ty_Integer) → new_esEs25(zwu4000, zwu6000)
new_esEs9(zwu401, zwu601, app(ty_[], bfh)) → new_esEs15(zwu401, zwu601, bfh)
new_ltEs21(zwu731, zwu741, app(app(ty_@2, dbc), dbd)) → new_ltEs17(zwu731, zwu741, dbc, dbd)
new_esEs21(LT, LT) → True
new_esEs35(zwu4000, zwu6000, ty_Float) → new_esEs23(zwu4000, zwu6000)
new_lt24(zwu40, zwu60, app(ty_[], gb)) → new_lt16(zwu40, zwu60, gb)
new_lt24(zwu40, zwu60, ty_@0) → new_lt12(zwu40, zwu60)
new_esEs7(zwu402, zwu602, ty_Float) → new_esEs23(zwu402, zwu602)
new_ltEs20(zwu111, zwu112, app(ty_Ratio, cda)) → new_ltEs7(zwu111, zwu112, cda)
new_esEs33(zwu4000, zwu6000, ty_Double) → new_esEs19(zwu4000, zwu6000)
new_esEs32(zwu137, zwu140, ty_Float) → new_esEs23(zwu137, zwu140)
new_esEs20(@0, @0) → True
new_lt24(zwu40, zwu60, app(app(ty_@2, hf), hg)) → new_lt17(zwu40, zwu60, hf, hg)
new_esEs29(zwu731, zwu741, app(ty_Maybe, cad)) → new_esEs14(zwu731, zwu741, cad)
new_esEs32(zwu137, zwu140, app(app(app(ty_@3, ddf), ddg), ddh)) → new_esEs13(zwu137, zwu140, ddf, ddg, ddh)
new_esEs15(:(zwu4000, zwu4001), :(zwu6000, zwu6001), fcb) → new_asAs(new_esEs35(zwu4000, zwu6000, fcb), new_esEs15(zwu4001, zwu6001, fcb))
new_esEs29(zwu731, zwu741, ty_Char) → new_esEs18(zwu731, zwu741)
new_ltEs21(zwu731, zwu741, ty_Double) → new_ltEs8(zwu731, zwu741)
new_esEs9(zwu401, zwu601, app(app(ty_Either, bgc), bgd)) → new_esEs22(zwu401, zwu601, bgc, bgd)
new_lt19(zwu731, zwu741, app(ty_[], cah)) → new_lt16(zwu731, zwu741, cah)
new_esEs14(Just(zwu4000), Just(zwu6000), ty_@0) → new_esEs20(zwu4000, zwu6000)
new_ltEs23(zwu73, zwu74, ty_Char) → new_ltEs11(zwu73, zwu74)
new_esEs38(zwu4000, zwu6000, app(app(app(ty_@3, fff), ffg), ffh)) → new_esEs13(zwu4000, zwu6000, fff, ffg, ffh)
new_esEs29(zwu731, zwu741, app(app(ty_@2, cba), cbb)) → new_esEs17(zwu731, zwu741, cba, cbb)
new_compare14(@0, @0) → EQ
new_lt20(zwu730, zwu740, app(app(ty_@2, bhg), bhh)) → new_lt17(zwu730, zwu740, bhg, bhh)
new_ltEs23(zwu73, zwu74, ty_Float) → new_ltEs14(zwu73, zwu74)
new_esEs30(zwu730, zwu740, ty_Ordering) → new_esEs21(zwu730, zwu740)
new_esEs11(zwu400, zwu600, app(ty_[], edh)) → new_esEs15(zwu400, zwu600, edh)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_lt5(zwu149, zwu151, ty_Int) → new_lt15(zwu149, zwu151)
new_esEs21(GT, EQ) → False
new_esEs21(EQ, GT) → False
new_esEs31(zwu136, zwu139, ty_Integer) → new_esEs25(zwu136, zwu139)
new_esEs28(zwu730, zwu740, app(app(ty_Either, caa), cab)) → new_esEs22(zwu730, zwu740, caa, cab)
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_ltEs18(Right(zwu730), Right(zwu740), cff, app(app(ty_@2, cge), cgf)) → new_ltEs17(zwu730, zwu740, cge, cgf)
new_esEs11(zwu400, zwu600, ty_Char) → new_esEs18(zwu400, zwu600)
new_esEs4(zwu400, zwu600, app(ty_Ratio, fdg)) → new_esEs24(zwu400, zwu600, fdg)
new_lt20(zwu730, zwu740, ty_Ordering) → new_lt6(zwu730, zwu740)
new_ltEs24(zwu118, zwu119, ty_Ordering) → new_ltEs5(zwu118, zwu119)
new_esEs5(zwu400, zwu600, app(ty_Ratio, dc)) → new_esEs24(zwu400, zwu600, dc)
new_ltEs22(zwu138, zwu141, ty_Ordering) → new_ltEs5(zwu138, zwu141)
new_lt22(zwu136, zwu139, app(ty_Maybe, dcc)) → new_lt4(zwu136, zwu139, dcc)
new_ltEs21(zwu731, zwu741, app(ty_[], dbb)) → new_ltEs16(zwu731, zwu741, dbb)
new_esEs9(zwu401, zwu601, ty_Float) → new_esEs23(zwu401, zwu601)
new_ltEs9(Just(zwu730), Just(zwu740), ty_Double) → new_ltEs8(zwu730, zwu740)
new_lt5(zwu149, zwu151, app(ty_Ratio, bad)) → new_lt8(zwu149, zwu151, bad)
new_ltEs20(zwu111, zwu112, app(ty_Maybe, cdb)) → new_ltEs9(zwu111, zwu112, cdb)
new_esEs34(zwu4001, zwu6001, app(app(ty_Either, ebg), ebh)) → new_esEs22(zwu4001, zwu6001, ebg, ebh)
new_compare7(zwu400, zwu600, app(ty_[], gh)) → new_compare0(zwu400, zwu600, gh)
new_lt24(zwu40, zwu60, app(app(app(ty_@3, bf), bg), bh)) → new_lt13(zwu40, zwu60, bf, bg, bh)
new_esEs39(zwu4001, zwu6001, ty_@0) → new_esEs20(zwu4001, zwu6001)
new_esEs22(Right(zwu4000), Right(zwu6000), fag, app(app(app(ty_@3, fah), fba), fbb)) → new_esEs13(zwu4000, zwu6000, fah, fba, fbb)
new_esEs6(zwu401, zwu601, ty_Ordering) → new_esEs21(zwu401, zwu601)
new_lt20(zwu730, zwu740, ty_Int) → new_lt15(zwu730, zwu740)
new_compare6(Just(zwu400), Just(zwu600), ga) → new_compare29(zwu400, zwu600, new_esEs4(zwu400, zwu600, ga), ga)
new_esEs11(zwu400, zwu600, ty_Float) → new_esEs23(zwu400, zwu600)
new_ltEs22(zwu138, zwu141, ty_Integer) → new_ltEs10(zwu138, zwu141)
new_esEs7(zwu402, zwu602, app(ty_Ratio, fh)) → new_esEs24(zwu402, zwu602, fh)
new_lt21(zwu730, zwu740, ty_Bool) → new_lt7(zwu730, zwu740)
new_esEs31(zwu136, zwu139, ty_Double) → new_esEs19(zwu136, zwu139)
new_lt5(zwu149, zwu151, app(app(app(ty_@3, baf), bag), bah)) → new_lt13(zwu149, zwu151, baf, bag, bah)
new_lt22(zwu136, zwu139, ty_Ordering) → new_lt6(zwu136, zwu139)
new_sr(zwu400, zwu601) → new_primMulInt(zwu400, zwu601)
new_esEs29(zwu731, zwu741, ty_Float) → new_esEs23(zwu731, zwu741)
new_esEs14(Just(zwu4000), Just(zwu6000), app(ty_Maybe, feg)) → new_esEs14(zwu4000, zwu6000, feg)
new_ltEs21(zwu731, zwu741, ty_Ordering) → new_ltEs5(zwu731, zwu741)
new_esEs31(zwu136, zwu139, app(ty_[], dcg)) → new_esEs15(zwu136, zwu139, dcg)
new_compare7(zwu400, zwu600, app(ty_Maybe, gd)) → new_compare6(zwu400, zwu600, gd)
new_esEs5(zwu400, zwu600, ty_Integer) → new_esEs25(zwu400, zwu600)
new_lt22(zwu136, zwu139, app(ty_[], dcg)) → new_lt16(zwu136, zwu139, dcg)
new_esEs9(zwu401, zwu601, ty_Ordering) → new_esEs21(zwu401, zwu601)
new_esEs38(zwu4000, zwu6000, app(ty_[], fgb)) → new_esEs15(zwu4000, zwu6000, fgb)
new_lt24(zwu40, zwu60, app(app(ty_Either, hh), baa)) → new_lt18(zwu40, zwu60, hh, baa)
new_ltEs19(zwu732, zwu742, app(ty_Maybe, cbf)) → new_ltEs9(zwu732, zwu742, cbf)
new_esEs8(zwu400, zwu600, ty_Char) → new_esEs18(zwu400, zwu600)
new_esEs29(zwu731, zwu741, ty_Int) → new_esEs12(zwu731, zwu741)
new_ltEs18(Right(zwu730), Right(zwu740), cff, ty_Integer) → new_ltEs10(zwu730, zwu740)
new_esEs14(Just(zwu4000), Nothing, fec) → False
new_esEs14(Nothing, Just(zwu6000), fec) → False
new_ltEs18(Right(zwu730), Right(zwu740), cff, app(ty_Maybe, cfh)) → new_ltEs9(zwu730, zwu740, cfh)
new_esEs39(zwu4001, zwu6001, app(app(ty_@2, fhe), fhf)) → new_esEs17(zwu4001, zwu6001, fhe, fhf)
new_ltEs19(zwu732, zwu742, app(app(ty_@2, ccc), ccd)) → new_ltEs17(zwu732, zwu742, ccc, ccd)
new_esEs22(Left(zwu4000), Left(zwu6000), ty_Ordering, ehg) → new_esEs21(zwu4000, zwu6000)
new_ltEs12(zwu73, zwu74) → new_fsEs(new_compare14(zwu73, zwu74))
new_esEs5(zwu400, zwu600, ty_Float) → new_esEs23(zwu400, zwu600)
new_esEs38(zwu4000, zwu6000, ty_@0) → new_esEs20(zwu4000, zwu6000)
new_lt19(zwu731, zwu741, ty_Bool) → new_lt7(zwu731, zwu741)
new_lt19(zwu731, zwu741, ty_Integer) → new_lt10(zwu731, zwu741)
new_ltEs18(Right(zwu730), Right(zwu740), cff, ty_@0) → new_ltEs12(zwu730, zwu740)
new_compare18(Left(zwu400), Left(zwu600), hh, baa) → new_compare27(zwu400, zwu600, new_esEs10(zwu400, zwu600, hh), hh, baa)
new_esEs16(True, False) → False
new_esEs16(False, True) → False
new_lt23(zwu137, zwu140, ty_Bool) → new_lt7(zwu137, zwu140)
new_esEs27(zwu149, zwu151, ty_Int) → new_esEs12(zwu149, zwu151)
new_esEs33(zwu4000, zwu6000, ty_Bool) → new_esEs16(zwu4000, zwu6000)
new_esEs39(zwu4001, zwu6001, ty_Bool) → new_esEs16(zwu4001, zwu6001)
new_ltEs20(zwu111, zwu112, ty_@0) → new_ltEs12(zwu111, zwu112)
new_lt22(zwu136, zwu139, ty_Int) → new_lt15(zwu136, zwu139)
new_esEs26(GT) → False
new_lt24(zwu40, zwu60, app(ty_Maybe, ga)) → new_lt4(zwu40, zwu60, ga)
new_primEqInt(Neg(Zero), Neg(Succ(zwu60000))) → False
new_primEqInt(Neg(Succ(zwu40000)), Neg(Zero)) → False
new_lt9(zwu40, zwu60) → new_esEs26(new_compare11(zwu40, zwu60))
new_ltEs24(zwu118, zwu119, app(ty_[], egg)) → new_ltEs16(zwu118, zwu119, egg)
new_esEs28(zwu730, zwu740, ty_Integer) → new_esEs25(zwu730, zwu740)
new_esEs14(Just(zwu4000), Just(zwu6000), app(ty_[], feh)) → new_esEs15(zwu4000, zwu6000, feh)
new_esEs33(zwu4000, zwu6000, ty_Int) → new_esEs12(zwu4000, zwu6000)
new_lt18(zwu40, zwu60, hh, baa) → new_esEs26(new_compare18(zwu40, zwu60, hh, baa))
new_esEs29(zwu731, zwu741, ty_Bool) → new_esEs16(zwu731, zwu741)
new_esEs8(zwu400, zwu600, ty_Int) → new_esEs12(zwu400, zwu600)
new_gt(zwu24, zwu19, app(ty_Maybe, bda)) → new_esEs41(new_compare6(zwu24, zwu19, bda))
new_ltEs20(zwu111, zwu112, app(app(ty_Either, cea), ceb)) → new_ltEs18(zwu111, zwu112, cea, ceb)
new_esEs35(zwu4000, zwu6000, ty_Char) → new_esEs18(zwu4000, zwu6000)
new_ltEs22(zwu138, zwu141, ty_Char) → new_ltEs11(zwu138, zwu141)
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_ltEs5(EQ, EQ) → True
new_esEs29(zwu731, zwu741, app(ty_Ratio, cac)) → new_esEs24(zwu731, zwu741, cac)
new_compare7(zwu400, zwu600, ty_Char) → new_compare13(zwu400, zwu600)
new_compare27(zwu111, zwu112, True, ccg, cch) → EQ
new_compare8(GT, GT) → EQ
new_esEs11(zwu400, zwu600, ty_Bool) → new_esEs16(zwu400, zwu600)
new_ltEs20(zwu111, zwu112, ty_Float) → new_ltEs14(zwu111, zwu112)
new_esEs7(zwu402, zwu602, ty_Integer) → new_esEs25(zwu402, zwu602)
new_ltEs6(False, True) → True
new_esEs4(zwu400, zwu600, ty_Integer) → new_esEs25(zwu400, zwu600)
new_esEs39(zwu4001, zwu6001, ty_Double) → new_esEs19(zwu4001, zwu6001)
new_ltEs6(True, True) → True
new_lt20(zwu730, zwu740, ty_@0) → new_lt12(zwu730, zwu740)
new_lt22(zwu136, zwu139, ty_Bool) → new_lt7(zwu136, zwu139)
new_ltEs24(zwu118, zwu119, ty_Int) → new_ltEs15(zwu118, zwu119)
new_esEs22(Right(zwu4000), Right(zwu6000), fag, ty_Bool) → new_esEs16(zwu4000, zwu6000)
new_compare6(Nothing, Nothing, ga) → EQ
new_primCompAux00(zwu94, LT) → LT
new_ltEs9(Just(zwu730), Just(zwu740), app(ty_Ratio, dga)) → new_ltEs7(zwu730, zwu740, dga)
new_esEs33(zwu4000, zwu6000, ty_@0) → new_esEs20(zwu4000, zwu6000)
new_esEs21(EQ, EQ) → True
new_esEs11(zwu400, zwu600, app(ty_Maybe, edg)) → new_esEs14(zwu400, zwu600, edg)
new_esEs32(zwu137, zwu140, app(ty_Maybe, dde)) → new_esEs14(zwu137, zwu140, dde)
new_ltEs22(zwu138, zwu141, app(app(app(ty_@3, deh), dfa), dfb)) → new_ltEs13(zwu138, zwu141, deh, dfa, dfb)
new_esEs35(zwu4000, zwu6000, ty_@0) → new_esEs20(zwu4000, zwu6000)
new_ltEs18(Left(zwu730), Left(zwu740), app(app(ty_@2, cfb), cfc), cec) → new_ltEs17(zwu730, zwu740, cfb, cfc)
new_esEs32(zwu137, zwu140, ty_@0) → new_esEs20(zwu137, zwu140)
new_esEs15([], [], fcb) → True
new_primEqInt(Pos(Zero), Pos(Succ(zwu60000))) → False
new_primEqInt(Pos(Succ(zwu40000)), Pos(Zero)) → False
new_compare7(zwu400, zwu600, ty_Int) → new_compare16(zwu400, zwu600)
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_ltEs5(GT, LT) → False
new_compare25(zwu136, zwu137, zwu138, zwu139, zwu140, zwu141, True, dbg, dbh, dca) → EQ
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_ltEs20(zwu111, zwu112, ty_Ordering) → new_ltEs5(zwu111, zwu112)
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_esEs4(zwu400, zwu600, ty_Float) → new_esEs23(zwu400, zwu600)
new_ltEs20(zwu111, zwu112, ty_Integer) → new_ltEs10(zwu111, zwu112)
new_ltEs9(Just(zwu730), Just(zwu740), app(ty_[], dgf)) → new_ltEs16(zwu730, zwu740, dgf)
new_sr0(Integer(zwu4000), Integer(zwu6010)) → Integer(new_primMulInt(zwu4000, zwu6010))
new_compare28(zwu118, zwu119, True, efh, ega) → EQ
new_primEqInt(Neg(Succ(zwu40000)), Pos(zwu6000)) → False
new_primEqInt(Pos(Succ(zwu40000)), Neg(zwu6000)) → False
new_esEs28(zwu730, zwu740, app(ty_Ratio, bha)) → new_esEs24(zwu730, zwu740, bha)
new_ltEs11(zwu73, zwu74) → new_fsEs(new_compare13(zwu73, zwu74))
new_compare7(zwu400, zwu600, ty_Float) → new_compare15(zwu400, zwu600)
new_lt23(zwu137, zwu140, ty_Ordering) → new_lt6(zwu137, zwu140)
new_esEs8(zwu400, zwu600, ty_Float) → new_esEs23(zwu400, zwu600)
new_compare15(Float(zwu400, zwu401), Float(zwu600, zwu601)) → new_compare16(new_sr(zwu400, zwu600), new_sr(zwu401, zwu601))
new_ltEs19(zwu732, zwu742, app(app(app(ty_@3, cbg), cbh), cca)) → new_ltEs13(zwu732, zwu742, cbg, cbh, cca)
new_esEs41(EQ) → False
new_esEs6(zwu401, zwu601, ty_Float) → new_esEs23(zwu401, zwu601)
new_ltEs23(zwu73, zwu74, ty_Double) → new_ltEs8(zwu73, zwu74)
new_compare7(zwu400, zwu600, app(app(ty_Either, hc), hd)) → new_compare18(zwu400, zwu600, hc, hd)
new_esEs7(zwu402, zwu602, app(app(ty_@2, fc), fd)) → new_esEs17(zwu402, zwu602, fc, fd)
new_esEs22(Right(zwu4000), Right(zwu6000), fag, app(ty_Ratio, fca)) → new_esEs24(zwu4000, zwu6000, fca)
new_esEs40(zwu4002, zwu6002, ty_Ordering) → new_esEs21(zwu4002, zwu6002)
new_ltEs9(Nothing, Nothing, dfh) → True
new_esEs4(zwu400, zwu600, app(app(ty_@2, dhd), dhe)) → new_esEs17(zwu400, zwu600, dhd, dhe)
new_ltEs20(zwu111, zwu112, ty_Char) → new_ltEs11(zwu111, zwu112)
new_lt5(zwu149, zwu151, ty_Bool) → new_lt7(zwu149, zwu151)
new_esEs40(zwu4002, zwu6002, ty_@0) → new_esEs20(zwu4002, zwu6002)
new_lt24(zwu40, zwu60, ty_Char) → new_lt11(zwu40, zwu60)
new_gt(zwu24, zwu19, app(app(app(ty_@3, bdb), bdc), bdd)) → new_esEs41(new_compare5(zwu24, zwu19, bdb, bdc, bdd))
new_compare12(Integer(zwu400), Integer(zwu600)) → new_primCmpInt(zwu400, zwu600)
new_esEs7(zwu402, zwu602, app(app(app(ty_@3, ef), eg), eh)) → new_esEs13(zwu402, zwu602, ef, eg, eh)
new_ltEs23(zwu73, zwu74, ty_Integer) → new_ltEs10(zwu73, zwu74)
new_ltEs4(zwu150, zwu152, app(ty_Maybe, bbg)) → new_ltEs9(zwu150, zwu152, bbg)
new_gt(zwu24, zwu19, ty_Int) → new_gt0(zwu24, zwu19)
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_esEs14(Just(zwu4000), Just(zwu6000), ty_Ordering) → new_esEs21(zwu4000, zwu6000)
new_esEs10(zwu400, zwu600, app(app(ty_@2, ecg), ech)) → new_esEs17(zwu400, zwu600, ecg, ech)
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_compare111(zwu233, zwu234, zwu235, zwu236, zwu237, zwu238, False, zwu240, efe, eff, efg) → new_compare114(zwu233, zwu234, zwu235, zwu236, zwu237, zwu238, zwu240, efe, eff, efg)
new_esEs33(zwu4000, zwu6000, app(app(app(ty_@3, dhf), dhg), dhh)) → new_esEs13(zwu4000, zwu6000, dhf, dhg, dhh)
new_ltEs18(Right(zwu730), Right(zwu740), cff, app(ty_[], cgd)) → new_ltEs16(zwu730, zwu740, cgd)
new_ltEs5(LT, GT) → True
new_ltEs18(Left(zwu730), Left(zwu740), ty_Int, cec) → new_ltEs15(zwu730, zwu740)
new_esEs31(zwu136, zwu139, ty_@0) → new_esEs20(zwu136, zwu139)
new_ltEs13(@3(zwu730, zwu731, zwu732), @3(zwu740, zwu741, zwu742), bgf, bgg, bgh) → new_pePe(new_lt20(zwu730, zwu740, bgf), new_asAs(new_esEs28(zwu730, zwu740, bgf), new_pePe(new_lt19(zwu731, zwu741, bgg), new_asAs(new_esEs29(zwu731, zwu741, bgg), new_ltEs19(zwu732, zwu742, bgh)))))
new_compare114(zwu233, zwu234, zwu235, zwu236, zwu237, zwu238, False, efe, eff, efg) → GT
new_esEs22(Left(zwu4000), Left(zwu6000), ty_Char, ehg) → new_esEs18(zwu4000, zwu6000)
new_gt0(zwu24, zwu19) → new_esEs41(new_compare16(zwu24, zwu19))
new_gt(zwu24, zwu19, ty_@0) → new_esEs41(new_compare14(zwu24, zwu19))
new_ltEs4(zwu150, zwu152, ty_Float) → new_ltEs14(zwu150, zwu152)
new_esEs34(zwu4001, zwu6001, ty_Integer) → new_esEs25(zwu4001, zwu6001)
new_primPlusNat0(Zero, Zero) → Zero
new_esEs7(zwu402, zwu602, ty_Ordering) → new_esEs21(zwu402, zwu602)
new_ltEs18(Right(zwu730), Right(zwu740), cff, ty_Char) → new_ltEs11(zwu730, zwu740)
new_primEqInt(Pos(Zero), Pos(Zero)) → True
new_lt23(zwu137, zwu140, ty_Char) → new_lt11(zwu137, zwu140)
new_ltEs18(Left(zwu730), Left(zwu740), ty_Float, cec) → new_ltEs14(zwu730, zwu740)
new_esEs14(Just(zwu4000), Just(zwu6000), ty_Bool) → new_esEs16(zwu4000, zwu6000)
new_esEs5(zwu400, zwu600, app(app(app(ty_@3, ca), cb), cc)) → new_esEs13(zwu400, zwu600, ca, cb, cc)
new_ltEs9(Just(zwu730), Just(zwu740), ty_Float) → new_ltEs14(zwu730, zwu740)
new_esEs40(zwu4002, zwu6002, ty_Float) → new_esEs23(zwu4002, zwu6002)
new_compare8(GT, EQ) → GT
new_esEs6(zwu401, zwu601, app(app(app(ty_@3, dd), de), df)) → new_esEs13(zwu401, zwu601, dd, de, df)
new_esEs16(True, True) → True
new_esEs34(zwu4001, zwu6001, ty_Ordering) → new_esEs21(zwu4001, zwu6001)
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_compare13(Char(zwu400), Char(zwu600)) → new_primCmpNat0(zwu400, zwu600)
new_ltEs20(zwu111, zwu112, app(app(app(ty_@3, cdc), cdd), cde)) → new_ltEs13(zwu111, zwu112, cdc, cdd, cde)
new_esEs32(zwu137, zwu140, ty_Bool) → new_esEs16(zwu137, zwu140)
new_ltEs21(zwu731, zwu741, ty_Float) → new_ltEs14(zwu731, zwu741)
new_compare10(:%(zwu400, zwu401), :%(zwu600, zwu601), ty_Int) → new_compare16(new_sr(zwu400, zwu601), new_sr(zwu600, zwu401))
new_lt19(zwu731, zwu741, ty_Double) → new_lt9(zwu731, zwu741)
new_lt20(zwu730, zwu740, app(ty_[], bhf)) → new_lt16(zwu730, zwu740, bhf)
new_esEs22(Right(zwu4000), Right(zwu6000), fag, ty_Char) → new_esEs18(zwu4000, zwu6000)
new_ltEs23(zwu73, zwu74, ty_Bool) → new_ltEs6(zwu73, zwu74)
new_compare29(zwu73, zwu74, True, efa) → EQ
new_esEs11(zwu400, zwu600, app(app(app(ty_@3, edd), ede), edf)) → new_esEs13(zwu400, zwu600, edd, ede, edf)
new_ltEs7(zwu73, zwu74, eef) → new_fsEs(new_compare10(zwu73, zwu74, eef))
new_esEs29(zwu731, zwu741, ty_Double) → new_esEs19(zwu731, zwu741)
new_esEs30(zwu730, zwu740, app(app(app(ty_@3, che), chf), chg)) → new_esEs13(zwu730, zwu740, che, chf, chg)
new_esEs28(zwu730, zwu740, ty_Float) → new_esEs23(zwu730, zwu740)
new_ltEs19(zwu732, zwu742, ty_Char) → new_ltEs11(zwu732, zwu742)
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_compare11(Double(zwu400, zwu401), Double(zwu600, zwu601)) → new_compare16(new_sr(zwu400, zwu600), new_sr(zwu401, zwu601))
new_ltEs5(LT, EQ) → True
new_esEs39(zwu4001, zwu6001, ty_Float) → new_esEs23(zwu4001, zwu6001)
new_esEs4(zwu400, zwu600, ty_Bool) → new_esEs16(zwu400, zwu600)
new_lt14(zwu40, zwu60) → new_esEs26(new_compare15(zwu40, zwu60))
new_ltEs23(zwu73, zwu74, app(app(app(ty_@3, bgf), bgg), bgh)) → new_ltEs13(zwu73, zwu74, bgf, bgg, bgh)
new_lt21(zwu730, zwu740, app(app(app(ty_@3, che), chf), chg)) → new_lt13(zwu730, zwu740, che, chf, chg)
new_ltEs20(zwu111, zwu112, ty_Bool) → new_ltEs6(zwu111, zwu112)
new_esEs37(zwu4001, zwu6001, ty_Int) → new_esEs12(zwu4001, zwu6001)
new_ltEs4(zwu150, zwu152, app(app(ty_@2, bcd), bce)) → new_ltEs17(zwu150, zwu152, bcd, bce)
new_compare7(zwu400, zwu600, app(app(ty_@2, ha), hb)) → new_compare17(zwu400, zwu600, ha, hb)
new_lt24(zwu40, zwu60, app(ty_Ratio, he)) → new_lt8(zwu40, zwu60, he)
new_lt24(zwu40, zwu60, ty_Double) → new_lt9(zwu40, zwu60)
new_esEs5(zwu400, zwu600, app(ty_Maybe, cd)) → new_esEs14(zwu400, zwu600, cd)
new_esEs25(Integer(zwu4000), Integer(zwu6000)) → new_primEqInt(zwu4000, zwu6000)
new_compare111(zwu233, zwu234, zwu235, zwu236, zwu237, zwu238, True, zwu240, efe, eff, efg) → new_compare114(zwu233, zwu234, zwu235, zwu236, zwu237, zwu238, True, efe, eff, efg)
new_esEs10(zwu400, zwu600, app(ty_Maybe, ece)) → new_esEs14(zwu400, zwu600, ece)
new_lt5(zwu149, zwu151, app(app(ty_Either, bbd), bbe)) → new_lt18(zwu149, zwu151, bbd, bbe)
new_esEs38(zwu4000, zwu6000, app(ty_Ratio, fgg)) → new_esEs24(zwu4000, zwu6000, fgg)
new_ltEs21(zwu731, zwu741, ty_@0) → new_ltEs12(zwu731, zwu741)
new_lt22(zwu136, zwu139, app(app(ty_Either, ddb), ddc)) → new_lt18(zwu136, zwu139, ddb, ddc)
new_lt22(zwu136, zwu139, ty_Double) → new_lt9(zwu136, zwu139)
new_compare8(EQ, LT) → GT
new_ltEs23(zwu73, zwu74, app(app(ty_@2, cha), chb)) → new_ltEs17(zwu73, zwu74, cha, chb)
new_lt5(zwu149, zwu151, ty_Char) → new_lt11(zwu149, zwu151)
new_esEs14(Just(zwu4000), Just(zwu6000), ty_Float) → new_esEs23(zwu4000, zwu6000)
new_esEs16(False, False) → True
new_esEs38(zwu4000, zwu6000, ty_Float) → new_esEs23(zwu4000, zwu6000)
new_esEs41(LT) → False
new_compare5(@3(zwu400, zwu401, zwu402), @3(zwu600, zwu601, zwu602), bf, bg, bh) → new_compare25(zwu400, zwu401, zwu402, zwu600, zwu601, zwu602, new_asAs(new_esEs5(zwu400, zwu600, bf), new_asAs(new_esEs6(zwu401, zwu601, bg), new_esEs7(zwu402, zwu602, bh))), bf, bg, bh)
new_compare9(False, True) → LT
new_esEs32(zwu137, zwu140, app(app(ty_@2, deb), dec)) → new_esEs17(zwu137, zwu140, deb, dec)
new_esEs30(zwu730, zwu740, app(ty_Maybe, chd)) → new_esEs14(zwu730, zwu740, chd)
new_gt(zwu24, zwu19, ty_Char) → new_esEs41(new_compare13(zwu24, zwu19))
new_esEs5(zwu400, zwu600, app(app(ty_@2, cf), cg)) → new_esEs17(zwu400, zwu600, cf, cg)
new_lt24(zwu40, zwu60, ty_Float) → new_lt14(zwu40, zwu60)
new_lt22(zwu136, zwu139, ty_Integer) → new_lt10(zwu136, zwu139)
new_ltEs23(zwu73, zwu74, ty_Ordering) → new_ltEs5(zwu73, zwu74)
new_lt23(zwu137, zwu140, app(app(ty_@2, deb), dec)) → new_lt17(zwu137, zwu140, deb, dec)
new_esEs30(zwu730, zwu740, ty_Int) → new_esEs12(zwu730, zwu740)
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_lt19(zwu731, zwu741, app(ty_Maybe, cad)) → new_lt4(zwu731, zwu741, cad)
new_ltEs24(zwu118, zwu119, app(app(ty_Either, ehb), ehc)) → new_ltEs18(zwu118, zwu119, ehb, ehc)
new_ltEs19(zwu732, zwu742, ty_Int) → new_ltEs15(zwu732, zwu742)
new_esEs4(zwu400, zwu600, ty_Ordering) → new_esEs21(zwu400, zwu600)
new_ltEs22(zwu138, zwu141, app(app(ty_@2, dfd), dfe)) → new_ltEs17(zwu138, zwu141, dfd, dfe)
new_ltEs23(zwu73, zwu74, ty_@0) → new_ltEs12(zwu73, zwu74)
new_ltEs20(zwu111, zwu112, ty_Double) → new_ltEs8(zwu111, zwu112)
new_esEs7(zwu402, zwu602, ty_Bool) → new_esEs16(zwu402, zwu602)
new_lt5(zwu149, zwu151, ty_Ordering) → new_lt6(zwu149, zwu151)
new_gt(zwu24, zwu19, ty_Bool) → new_esEs41(new_compare9(zwu24, zwu19))
new_ltEs18(Left(zwu730), Left(zwu740), app(ty_Ratio, ced), cec) → new_ltEs7(zwu730, zwu740, ced)
new_esEs30(zwu730, zwu740, ty_Double) → new_esEs19(zwu730, zwu740)
new_compare112(zwu165, zwu166, False, efb) → GT
new_ltEs21(zwu731, zwu741, ty_Bool) → new_ltEs6(zwu731, zwu741)
new_ltEs4(zwu150, zwu152, ty_Ordering) → new_ltEs5(zwu150, zwu152)
new_lt21(zwu730, zwu740, app(app(ty_Either, dac), dad)) → new_lt18(zwu730, zwu740, dac, dad)
new_esEs29(zwu731, zwu741, app(app(ty_Either, cbc), cbd)) → new_esEs22(zwu731, zwu741, cbc, cbd)
new_lt12(zwu40, zwu60) → new_esEs26(new_compare14(zwu40, zwu60))
new_esEs8(zwu400, zwu600, ty_Bool) → new_esEs16(zwu400, zwu600)
new_esEs31(zwu136, zwu139, ty_Float) → new_esEs23(zwu136, zwu139)
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_esEs35(zwu4000, zwu6000, app(ty_[], fcg)) → new_esEs15(zwu4000, zwu6000, fcg)
new_lt8(zwu40, zwu60, he) → new_esEs26(new_compare10(zwu40, zwu60, he))
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_ltEs19(zwu732, zwu742, ty_Ordering) → new_ltEs5(zwu732, zwu742)
new_esEs22(Left(zwu4000), Left(zwu6000), ty_Double, ehg) → new_esEs19(zwu4000, zwu6000)
new_esEs7(zwu402, zwu602, ty_@0) → new_esEs20(zwu402, zwu602)
new_compare26(zwu149, zwu150, zwu151, zwu152, True, bab, bac) → EQ
new_compare115(zwu189, zwu190, False, fde, fdf) → GT
new_esEs9(zwu401, zwu601, ty_Double) → new_esEs19(zwu401, zwu601)
new_compare25(zwu136, zwu137, zwu138, zwu139, zwu140, zwu141, False, dbg, dbh, dca) → new_compare111(zwu136, zwu137, zwu138, zwu139, zwu140, zwu141, new_lt22(zwu136, zwu139, dbg), new_asAs(new_esEs31(zwu136, zwu139, dbg), new_pePe(new_lt23(zwu137, zwu140, dbh), new_asAs(new_esEs32(zwu137, zwu140, dbh), new_ltEs22(zwu138, zwu141, dca)))), dbg, dbh, dca)
new_esEs29(zwu731, zwu741, ty_Ordering) → new_esEs21(zwu731, zwu741)
new_esEs34(zwu4001, zwu6001, app(ty_Maybe, ebc)) → new_esEs14(zwu4001, zwu6001, ebc)
new_esEs9(zwu401, zwu601, ty_Bool) → new_esEs16(zwu401, zwu601)
new_lt5(zwu149, zwu151, ty_Double) → new_lt9(zwu149, zwu151)
new_esEs10(zwu400, zwu600, app(app(ty_Either, eda), edb)) → new_esEs22(zwu400, zwu600, eda, edb)
new_esEs33(zwu4000, zwu6000, ty_Char) → new_esEs18(zwu4000, zwu6000)
new_lt5(zwu149, zwu151, app(app(ty_@2, bbb), bbc)) → new_lt17(zwu149, zwu151, bbb, bbc)
new_ltEs21(zwu731, zwu741, app(app(ty_Either, dbe), dbf)) → new_ltEs18(zwu731, zwu741, dbe, dbf)
new_esEs9(zwu401, zwu601, ty_Char) → new_esEs18(zwu401, zwu601)
new_lt23(zwu137, zwu140, app(app(ty_Either, ded), dee)) → new_lt18(zwu137, zwu140, ded, dee)
new_esEs21(EQ, LT) → False
new_esEs21(LT, EQ) → False
new_esEs27(zwu149, zwu151, ty_Char) → new_esEs18(zwu149, zwu151)
new_compare19(zwu248, zwu249, zwu250, zwu251, True, zwu253, efc, efd) → new_compare113(zwu248, zwu249, zwu250, zwu251, True, efc, efd)
new_esEs4(zwu400, zwu600, app(ty_Maybe, fec)) → new_esEs14(zwu400, zwu600, fec)
new_esEs28(zwu730, zwu740, ty_Char) → new_esEs18(zwu730, zwu740)
new_lt19(zwu731, zwu741, app(app(ty_@2, cba), cbb)) → new_lt17(zwu731, zwu741, cba, cbb)
new_lt23(zwu137, zwu140, ty_Int) → new_lt15(zwu137, zwu140)
new_ltEs24(zwu118, zwu119, app(app(app(ty_@3, egd), ege), egf)) → new_ltEs13(zwu118, zwu119, egd, ege, egf)
new_esEs11(zwu400, zwu600, app(app(ty_Either, eec), eed)) → new_esEs22(zwu400, zwu600, eec, eed)
new_esEs34(zwu4001, zwu6001, app(app(app(ty_@3, eah), eba), ebb)) → new_esEs13(zwu4001, zwu6001, eah, eba, ebb)
new_primCompAux00(zwu94, GT) → GT
new_esEs7(zwu402, zwu602, app(ty_Maybe, fa)) → new_esEs14(zwu402, zwu602, fa)
new_ltEs4(zwu150, zwu152, ty_Char) → new_ltEs11(zwu150, zwu152)
new_fsEs(zwu255) → new_not(new_esEs21(zwu255, GT))
new_lt20(zwu730, zwu740, app(ty_Maybe, bhb)) → new_lt4(zwu730, zwu740, bhb)
new_ltEs22(zwu138, zwu141, app(ty_Maybe, deg)) → new_ltEs9(zwu138, zwu141, deg)
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_esEs32(zwu137, zwu140, ty_Char) → new_esEs18(zwu137, zwu140)
new_ltEs16(zwu73, zwu74, dhc) → new_fsEs(new_compare0(zwu73, zwu74, dhc))
new_esEs22(Right(zwu4000), Right(zwu6000), fag, app(app(ty_Either, fbg), fbh)) → new_esEs22(zwu4000, zwu6000, fbg, fbh)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_esEs32(zwu137, zwu140, ty_Ordering) → new_esEs21(zwu137, zwu140)

The set Q consists of the following terms:

new_ltEs23(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_ltEs18(Right(x0), Right(x1), x2, ty_Bool)
new_compare9(True, False)
new_compare9(False, True)
new_esEs38(x0, x1, ty_Float)
new_esEs32(x0, x1, ty_Double)
new_esEs21(LT, LT)
new_esEs22(Right(x0), Right(x1), x2, ty_Bool)
new_primMulNat0(Zero, Succ(x0))
new_ltEs22(x0, x1, ty_Char)
new_esEs32(x0, x1, ty_Int)
new_compare110(x0, x1, True, x2, x3)
new_ltEs18(Right(x0), Right(x1), x2, app(app(ty_@2, x3), x4))
new_ltEs21(x0, x1, app(ty_Maybe, x2))
new_ltEs18(Left(x0), Left(x1), ty_Ordering, x2)
new_esEs40(x0, x1, ty_Bool)
new_esEs22(Left(x0), Left(x1), ty_@0, x2)
new_esEs7(x0, x1, ty_Int)
new_primEqInt(Neg(Zero), Neg(Succ(x0)))
new_esEs27(x0, x1, ty_Int)
new_esEs29(x0, x1, app(app(ty_Either, x2), x3))
new_esEs27(x0, x1, ty_Bool)
new_sr(x0, x1)
new_lt21(x0, x1, app(ty_Ratio, x2))
new_lt21(x0, x1, ty_Ordering)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_ltEs9(Just(x0), Just(x1), app(app(ty_Either, x2), x3))
new_esEs7(x0, x1, ty_Integer)
new_esEs27(x0, x1, app(ty_[], x2))
new_lt19(x0, x1, ty_@0)
new_esEs22(Right(x0), Right(x1), x2, app(ty_[], x3))
new_ltEs21(x0, x1, ty_Bool)
new_esEs4(x0, x1, ty_Float)
new_ltEs21(x0, x1, app(ty_[], x2))
new_compare115(x0, x1, True, x2, x3)
new_esEs9(x0, x1, ty_Float)
new_ltEs24(x0, x1, ty_Int)
new_esEs22(Right(x0), Right(x1), x2, ty_@0)
new_esEs14(Just(x0), Nothing, x1)
new_ltEs24(x0, x1, ty_Double)
new_esEs22(Left(x0), Left(x1), ty_Ordering, x2)
new_esEs30(x0, x1, ty_Bool)
new_compare10(:%(x0, x1), :%(x2, x3), ty_Int)
new_esEs7(x0, x1, ty_Float)
new_esEs10(x0, x1, app(app(ty_Either, x2), x3))
new_esEs8(x0, x1, app(ty_Ratio, x2))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_esEs14(Just(x0), Just(x1), ty_Int)
new_ltEs9(Nothing, Nothing, x0)
new_esEs5(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs22(x0, x1, ty_Double)
new_esEs38(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_compare9(True, True)
new_esEs6(x0, x1, ty_@0)
new_compare110(x0, x1, False, x2, x3)
new_ltEs9(Just(x0), Just(x1), ty_Char)
new_lt5(x0, x1, ty_@0)
new_ltEs6(True, True)
new_esEs39(x0, x1, app(app(ty_@2, x2), x3))
new_esEs16(False, True)
new_esEs16(True, False)
new_esEs30(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs21(x0, x1, app(app(ty_Either, x2), x3))
new_esEs34(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs20(x0, x1, ty_Double)
new_lt5(x0, x1, ty_Char)
new_esEs36(x0, x1, ty_Int)
new_esEs39(x0, x1, ty_@0)
new_ltEs22(x0, x1, ty_Integer)
new_lt18(x0, x1, x2, x3)
new_esEs21(EQ, GT)
new_esEs21(GT, EQ)
new_lt19(x0, x1, ty_Bool)
new_ltEs18(Left(x0), Left(x1), ty_@0, x2)
new_esEs28(x0, x1, ty_@0)
new_compare11(Double(x0, x1), Double(x2, x3))
new_esEs9(x0, x1, app(app(ty_Either, x2), x3))
new_ltEs18(Right(x0), Right(x1), x2, ty_Integer)
new_esEs5(x0, x1, ty_Float)
new_lt24(x0, x1, ty_Double)
new_lt23(x0, x1, app(ty_Ratio, x2))
new_ltEs5(EQ, LT)
new_ltEs5(LT, EQ)
new_ltEs19(x0, x1, ty_@0)
new_gt(x0, x1, app(ty_Ratio, x2))
new_primEqNat0(Zero, Zero)
new_esEs8(x0, x1, ty_Char)
new_esEs36(x0, x1, ty_Integer)
new_ltEs12(x0, x1)
new_primEqInt(Pos(Zero), Pos(Succ(x0)))
new_esEs28(x0, x1, ty_Char)
new_esEs37(x0, x1, ty_Int)
new_ltEs4(x0, x1, ty_Double)
new_compare6(Nothing, Just(x0), x1)
new_esEs4(x0, x1, app(ty_Maybe, x2))
new_ltEs19(x0, x1, app(ty_[], x2))
new_compare5(@3(x0, x1, x2), @3(x3, x4, x5), x6, x7, x8)
new_ltEs9(Just(x0), Just(x1), ty_Integer)
new_esEs11(x0, x1, ty_Float)
new_esEs30(x0, x1, app(ty_Maybe, x2))
new_esEs30(x0, x1, ty_Float)
new_compare18(Right(x0), Left(x1), x2, x3)
new_compare18(Left(x0), Right(x1), x2, x3)
new_esEs32(x0, x1, app(ty_[], x2))
new_ltEs24(x0, x1, app(app(ty_@2, x2), x3))
new_lt20(x0, x1, ty_Double)
new_compare19(x0, x1, x2, x3, True, x4, x5, x6)
new_primMulNat0(Zero, Zero)
new_sr0(Integer(x0), Integer(x1))
new_esEs35(x0, x1, ty_Float)
new_compare15(Float(x0, x1), Float(x2, x3))
new_lt15(x0, x1)
new_esEs8(x0, x1, ty_Bool)
new_esEs13(@3(x0, x1, x2), @3(x3, x4, x5), x6, x7, x8)
new_esEs22(Left(x0), Left(x1), app(ty_Maybe, x2), x3)
new_ltEs18(Left(x0), Left(x1), app(app(app(ty_@3, x2), x3), x4), x5)
new_esEs4(x0, x1, ty_Double)
new_ltEs4(x0, x1, app(ty_Ratio, x2))
new_esEs22(Left(x0), Left(x1), ty_Float, x2)
new_esEs4(x0, x1, ty_@0)
new_ltEs15(x0, x1)
new_ltEs20(x0, x1, ty_Char)
new_ltEs20(x0, x1, ty_Bool)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_lt20(x0, x1, ty_Float)
new_esEs8(x0, x1, ty_Ordering)
new_esEs5(x0, x1, app(ty_Maybe, x2))
new_esEs39(x0, x1, ty_Char)
new_primCmpNat0(Succ(x0), Zero)
new_esEs22(Left(x0), Left(x1), app(ty_Ratio, x2), x3)
new_lt5(x0, x1, app(app(ty_@2, x2), x3))
new_esEs8(x0, x1, app(ty_[], x2))
new_ltEs24(x0, x1, ty_@0)
new_compare8(EQ, EQ)
new_lt5(x0, x1, app(ty_Maybe, x2))
new_lt22(x0, x1, ty_Double)
new_esEs27(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_lt22(x0, x1, app(app(ty_@2, x2), x3))
new_esEs7(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs4(x0, x1, ty_Bool)
new_esEs9(x0, x1, ty_Int)
new_esEs22(Right(x0), Right(x1), x2, ty_Int)
new_lt19(x0, x1, app(ty_Ratio, x2))
new_ltEs20(x0, x1, ty_@0)
new_lt21(x0, x1, app(app(ty_@2, x2), x3))
new_esEs29(x0, x1, ty_Float)
new_esEs7(x0, x1, app(ty_Maybe, x2))
new_ltEs18(Left(x0), Left(x1), ty_Integer, x2)
new_esEs4(x0, x1, app(app(ty_@2, x2), x3))
new_gt(x0, x1, app(ty_[], x2))
new_esEs31(x0, x1, ty_Bool)
new_ltEs9(Just(x0), Just(x1), app(ty_Ratio, x2))
new_lt21(x0, x1, app(app(ty_Either, x2), x3))
new_primPlusNat0(Succ(x0), Succ(x1))
new_esEs10(x0, x1, ty_Int)
new_gt(x0, x1, ty_Integer)
new_esEs31(x0, x1, app(app(ty_Either, x2), x3))
new_esEs10(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_lt21(x0, x1, ty_Bool)
new_esEs31(x0, x1, ty_@0)
new_compare0([], [], x0)
new_lt24(x0, x1, app(ty_[], x2))
new_esEs14(Just(x0), Just(x1), ty_Ordering)
new_esEs40(x0, x1, ty_Float)
new_ltEs18(Left(x0), Left(x1), ty_Int, x2)
new_esEs30(x0, x1, ty_Double)
new_esEs12(x0, x1)
new_esEs31(x0, x1, ty_Int)
new_esEs22(Left(x0), Left(x1), app(app(ty_@2, x2), x3), x4)
new_esEs28(x0, x1, app(ty_[], x2))
new_esEs30(x0, x1, ty_Integer)
new_esEs14(Just(x0), Just(x1), app(app(ty_Either, x2), x3))
new_esEs14(Just(x0), Just(x1), ty_@0)
new_lt20(x0, x1, ty_Char)
new_primMulNat0(Succ(x0), Zero)
new_compare27(x0, x1, True, x2, x3)
new_ltEs7(x0, x1, x2)
new_esEs22(Left(x0), Left(x1), ty_Bool, x2)
new_gt(x0, x1, ty_@0)
new_esEs38(x0, x1, app(app(ty_@2, x2), x3))
new_esEs40(x0, x1, app(ty_Ratio, x2))
new_compare8(EQ, GT)
new_compare8(GT, EQ)
new_esEs29(x0, x1, app(ty_Ratio, x2))
new_ltEs4(x0, x1, ty_@0)
new_compare111(x0, x1, x2, x3, x4, x5, False, x6, x7, x8, x9)
new_ltEs24(x0, x1, ty_Ordering)
new_esEs35(x0, x1, ty_Char)
new_lt23(x0, x1, ty_Ordering)
new_esEs35(x0, x1, ty_Integer)
new_lt21(x0, x1, ty_Float)
new_esEs21(GT, LT)
new_esEs21(LT, GT)
new_esEs34(x0, x1, app(ty_Maybe, x2))
new_esEs14(Just(x0), Just(x1), ty_Double)
new_esEs29(x0, x1, ty_Double)
new_esEs34(x0, x1, ty_Char)
new_lt24(x0, x1, app(ty_Maybe, x2))
new_ltEs9(Just(x0), Just(x1), app(ty_Maybe, x2))
new_esEs31(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs5(x0, x1, ty_@0)
new_esEs32(x0, x1, ty_Integer)
new_compare26(x0, x1, x2, x3, False, x4, x5)
new_esEs5(x0, x1, ty_Char)
new_primMulInt(Neg(x0), Neg(x1))
new_primEqInt(Neg(Zero), Pos(Succ(x0)))
new_primEqInt(Pos(Zero), Neg(Succ(x0)))
new_esEs29(x0, x1, app(ty_[], x2))
new_esEs33(x0, x1, ty_Integer)
new_lt19(x0, x1, app(app(ty_Either, x2), x3))
new_compare18(Right(x0), Right(x1), x2, x3)
new_primCmpNat0(Zero, Succ(x0))
new_esEs4(x0, x1, ty_Integer)
new_ltEs22(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs33(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_ltEs4(x0, x1, app(app(ty_@2, x2), x3))
new_compare114(x0, x1, x2, x3, x4, x5, False, x6, x7, x8)
new_esEs38(x0, x1, app(ty_Maybe, x2))
new_esEs30(x0, x1, ty_Int)
new_ltEs24(x0, x1, app(ty_Ratio, x2))
new_esEs32(x0, x1, app(ty_Maybe, x2))
new_primCmpInt(Pos(Zero), Pos(Zero))
new_ltEs6(False, False)
new_ltEs20(x0, x1, app(app(ty_@2, x2), x3))
new_primEqInt(Pos(Succ(x0)), Pos(Zero))
new_esEs28(x0, x1, ty_Integer)
new_esEs9(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_primEqInt(Neg(Zero), Neg(Zero))
new_lt20(x0, x1, ty_Integer)
new_compare19(x0, x1, x2, x3, False, x4, x5, x6)
new_lt24(x0, x1, ty_Ordering)
new_esEs11(x0, x1, app(ty_Maybe, x2))
new_esEs22(Right(x0), Left(x1), x2, x3)
new_esEs22(Left(x0), Right(x1), x2, x3)
new_esEs4(x0, x1, app(ty_[], x2))
new_compare16(x0, x1)
new_esEs38(x0, x1, app(ty_Ratio, x2))
new_lt5(x0, x1, ty_Bool)
new_lt5(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_compare25(x0, x1, x2, x3, x4, x5, True, x6, x7, x8)
new_ltEs19(x0, x1, ty_Char)
new_esEs40(x0, x1, ty_Double)
new_ltEs20(x0, x1, ty_Ordering)
new_esEs31(x0, x1, app(ty_Ratio, x2))
new_esEs31(x0, x1, app(app(ty_@2, x2), x3))
new_primCompAux00(x0, LT)
new_esEs33(x0, x1, app(ty_Maybe, x2))
new_esEs32(x0, x1, ty_Char)
new_esEs27(x0, x1, ty_Integer)
new_gt(x0, x1, app(ty_Maybe, x2))
new_compare7(x0, x1, ty_Float)
new_esEs22(Right(x0), Right(x1), x2, ty_Float)
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_esEs33(x0, x1, ty_Float)
new_compare112(x0, x1, False, x2)
new_compare7(x0, x1, ty_Char)
new_ltEs4(x0, x1, ty_Char)
new_esEs10(x0, x1, ty_Float)
new_ltEs24(x0, x1, ty_Integer)
new_esEs34(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs22(Right(x0), Right(x1), x2, ty_Char)
new_esEs29(x0, x1, ty_@0)
new_esEs4(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_compare7(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs4(x0, x1, ty_Float)
new_esEs39(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs6(x0, x1, ty_Ordering)
new_lt14(x0, x1)
new_esEs38(x0, x1, ty_Char)
new_ltEs5(GT, LT)
new_ltEs5(LT, GT)
new_esEs9(x0, x1, ty_@0)
new_ltEs20(x0, x1, ty_Int)
new_esEs26(LT)
new_esEs9(x0, x1, app(ty_[], x2))
new_gt(x0, x1, ty_Double)
new_ltEs24(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs9(x0, x1, ty_Char)
new_esEs31(x0, x1, ty_Double)
new_lt21(x0, x1, ty_Double)
new_compare7(x0, x1, ty_Integer)
new_ltEs9(Just(x0), Just(x1), ty_Bool)
new_lt13(x0, x1, x2, x3, x4)
new_compare0([], :(x0, x1), x2)
new_esEs10(x0, x1, ty_Bool)
new_esEs11(x0, x1, ty_Integer)
new_lt10(x0, x1)
new_lt19(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_ltEs22(x0, x1, app(app(ty_@2, x2), x3))
new_compare111(x0, x1, x2, x3, x4, x5, True, x6, x7, x8, x9)
new_ltEs4(x0, x1, app(ty_[], x2))
new_esEs31(x0, x1, ty_Float)
new_esEs34(x0, x1, app(ty_Ratio, x2))
new_lt22(x0, x1, ty_@0)
new_ltEs22(x0, x1, app(ty_[], x2))
new_ltEs18(Left(x0), Left(x1), app(ty_Maybe, x2), x3)
new_esEs33(x0, x1, app(app(ty_Either, x2), x3))
new_esEs6(x0, x1, ty_Float)
new_compare8(GT, GT)
new_esEs40(x0, x1, ty_Int)
new_esEs30(x0, x1, app(ty_[], x2))
new_ltEs21(x0, x1, ty_@0)
new_ltEs5(GT, GT)
new_esEs9(x0, x1, app(app(ty_@2, x2), x3))
new_lt12(x0, x1)
new_primEqNat0(Zero, Succ(x0))
new_esEs30(x0, x1, app(ty_Ratio, x2))
new_compare7(x0, x1, app(ty_Ratio, x2))
new_esEs34(x0, x1, app(ty_[], x2))
new_esEs16(False, False)
new_compare7(x0, x1, ty_Double)
new_esEs14(Just(x0), Just(x1), ty_Bool)
new_lt4(x0, x1, x2)
new_ltEs18(Left(x0), Left(x1), app(app(ty_Either, x2), x3), x4)
new_esEs5(x0, x1, app(ty_[], x2))
new_esEs9(x0, x1, ty_Bool)
new_esEs39(x0, x1, ty_Float)
new_esEs6(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_primMulInt(Pos(x0), Pos(x1))
new_esEs6(x0, x1, app(ty_Ratio, x2))
new_ltEs23(x0, x1, app(app(ty_@2, x2), x3))
new_primCompAux00(x0, GT)
new_not(True)
new_esEs28(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_ltEs21(x0, x1, ty_Integer)
new_compare6(Just(x0), Nothing, x1)
new_esEs34(x0, x1, ty_Int)
new_esEs34(x0, x1, ty_@0)
new_esEs6(x0, x1, app(app(ty_@2, x2), x3))
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_not(False)
new_esEs40(x0, x1, ty_Ordering)
new_esEs6(x0, x1, app(ty_Maybe, x2))
new_esEs11(x0, x1, ty_Double)
new_esEs10(x0, x1, ty_Ordering)
new_ltEs21(x0, x1, ty_Float)
new_esEs39(x0, x1, ty_Bool)
new_esEs32(x0, x1, ty_Bool)
new_ltEs18(Right(x0), Right(x1), x2, app(app(ty_Either, x3), x4))
new_esEs30(x0, x1, ty_Char)
new_gt(x0, x1, app(app(ty_Either, x2), x3))
new_ltEs9(Just(x0), Just(x1), ty_Ordering)
new_esEs20(@0, @0)
new_esEs29(x0, x1, app(ty_Maybe, x2))
new_esEs5(x0, x1, ty_Ordering)
new_esEs4(x0, x1, ty_Ordering)
new_ltEs24(x0, x1, ty_Bool)
new_lt8(x0, x1, x2)
new_lt17(x0, x1, x2, x3)
new_ltEs18(Right(x0), Right(x1), x2, ty_Float)
new_ltEs23(x0, x1, ty_Integer)
new_gt(x0, x1, ty_Float)
new_esEs33(x0, x1, ty_@0)
new_esEs28(x0, x1, app(app(ty_@2, x2), x3))
new_esEs19(Double(x0, x1), Double(x2, x3))
new_lt5(x0, x1, ty_Integer)
new_esEs22(Right(x0), Right(x1), x2, app(app(ty_@2, x3), x4))
new_ltEs18(Left(x0), Left(x1), ty_Bool, x2)
new_lt23(x0, x1, ty_Integer)
new_esEs40(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs21(x0, x1, ty_Char)
new_esEs32(x0, x1, app(app(ty_Either, x2), x3))
new_lt22(x0, x1, app(ty_[], x2))
new_ltEs9(Just(x0), Just(x1), app(app(app(ty_@3, x2), x3), x4))
new_lt20(x0, x1, app(ty_Maybe, x2))
new_ltEs22(x0, x1, ty_Bool)
new_esEs22(Right(x0), Right(x1), x2, ty_Integer)
new_esEs15([], [], x0)
new_esEs29(x0, x1, ty_Char)
new_esEs22(Right(x0), Right(x1), x2, app(app(ty_Either, x3), x4))
new_esEs28(x0, x1, app(ty_Maybe, x2))
new_lt24(x0, x1, app(app(ty_@2, x2), x3))
new_compare27(x0, x1, False, x2, x3)
new_esEs27(x0, x1, app(app(ty_Either, x2), x3))
new_esEs33(x0, x1, ty_Int)
new_primMulNat0(Succ(x0), Succ(x1))
new_esEs27(x0, x1, app(ty_Maybe, x2))
new_compare7(x0, x1, app(ty_Maybe, x2))
new_lt19(x0, x1, ty_Float)
new_primEqInt(Pos(Zero), Pos(Zero))
new_lt22(x0, x1, ty_Bool)
new_esEs14(Just(x0), Just(x1), app(app(app(ty_@3, x2), x3), x4))
new_esEs29(x0, x1, ty_Integer)
new_asAs(False, x0)
new_esEs38(x0, x1, ty_@0)
new_esEs6(x0, x1, app(ty_[], x2))
new_pePe(True, x0)
new_esEs21(GT, GT)
new_esEs22(Right(x0), Right(x1), x2, ty_Double)
new_lt23(x0, x1, ty_Double)
new_esEs40(x0, x1, app(ty_[], x2))
new_ltEs14(x0, x1)
new_esEs11(x0, x1, ty_Bool)
new_esEs32(x0, x1, app(ty_Ratio, x2))
new_esEs30(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_compare9(False, False)
new_compare13(Char(x0), Char(x1))
new_esEs23(Float(x0, x1), Float(x2, x3))
new_lt23(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_ltEs5(LT, LT)
new_ltEs20(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs22(Right(x0), Right(x1), x2, app(ty_Maybe, x3))
new_esEs27(x0, x1, ty_Ordering)
new_ltEs24(x0, x1, ty_Float)
new_esEs22(Right(x0), Right(x1), x2, app(ty_Ratio, x3))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_compare8(LT, EQ)
new_esEs35(x0, x1, app(ty_Maybe, x2))
new_compare8(EQ, LT)
new_gt0(x0, x1)
new_esEs8(x0, x1, ty_Float)
new_esEs5(x0, x1, ty_Double)
new_lt23(x0, x1, ty_Char)
new_esEs38(x0, x1, ty_Bool)
new_esEs21(EQ, LT)
new_esEs21(LT, EQ)
new_ltEs19(x0, x1, ty_Float)
new_lt24(x0, x1, ty_Float)
new_ltEs18(Left(x0), Left(x1), ty_Char, x2)
new_esEs9(x0, x1, app(ty_Maybe, x2))
new_esEs9(x0, x1, ty_Integer)
new_lt21(x0, x1, ty_Int)
new_ltEs23(x0, x1, ty_Char)
new_primEqInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_ltEs24(x0, x1, app(ty_Maybe, x2))
new_esEs4(x0, x1, ty_Int)
new_esEs22(Left(x0), Left(x1), app(app(ty_Either, x2), x3), x4)
new_esEs38(x0, x1, ty_Integer)
new_esEs33(x0, x1, app(app(ty_@2, x2), x3))
new_primEqInt(Pos(Succ(x0)), Neg(x1))
new_primEqInt(Neg(Succ(x0)), Pos(x1))
new_compare26(x0, x1, x2, x3, True, x4, x5)
new_ltEs19(x0, x1, app(ty_Ratio, x2))
new_esEs31(x0, x1, app(ty_Maybe, x2))
new_gt(x0, x1, ty_Int)
new_esEs30(x0, x1, ty_Ordering)
new_esEs15([], :(x0, x1), x2)
new_esEs29(x0, x1, ty_Bool)
new_compare25(x0, x1, x2, x3, x4, x5, False, x6, x7, x8)
new_esEs35(x0, x1, ty_Int)
new_esEs8(x0, x1, ty_Integer)
new_lt23(x0, x1, app(ty_Maybe, x2))
new_ltEs20(x0, x1, app(ty_[], x2))
new_esEs14(Just(x0), Just(x1), ty_Char)
new_lt7(x0, x1)
new_esEs35(x0, x1, ty_@0)
new_esEs35(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs11(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs21(x0, x1, ty_Int)
new_esEs22(Left(x0), Left(x1), ty_Integer, x2)
new_ltEs21(x0, x1, app(ty_Ratio, x2))
new_ltEs18(Right(x0), Right(x1), x2, ty_@0)
new_gt(x0, x1, ty_Char)
new_ltEs18(Left(x0), Left(x1), app(ty_Ratio, x2), x3)
new_ltEs19(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_ltEs23(x0, x1, ty_Bool)
new_esEs14(Just(x0), Just(x1), app(ty_[], x2))
new_lt20(x0, x1, ty_@0)
new_esEs30(x0, x1, ty_@0)
new_ltEs23(x0, x1, ty_Double)
new_esEs8(x0, x1, app(ty_Maybe, x2))
new_ltEs5(GT, EQ)
new_ltEs5(EQ, GT)
new_lt5(x0, x1, app(ty_[], x2))
new_primCompAux00(x0, EQ)
new_esEs33(x0, x1, app(ty_Ratio, x2))
new_esEs39(x0, x1, ty_Integer)
new_esEs39(x0, x1, ty_Ordering)
new_ltEs20(x0, x1, ty_Float)
new_ltEs16(x0, x1, x2)
new_lt20(x0, x1, app(ty_Ratio, x2))
new_esEs11(x0, x1, ty_Int)
new_esEs34(x0, x1, ty_Bool)
new_lt24(x0, x1, app(app(ty_Either, x2), x3))
new_esEs5(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs38(x0, x1, app(ty_[], x2))
new_ltEs9(Just(x0), Just(x1), ty_Double)
new_esEs5(x0, x1, app(ty_Ratio, x2))
new_esEs34(x0, x1, ty_Ordering)
new_esEs9(x0, x1, ty_Double)
new_esEs39(x0, x1, app(ty_Maybe, x2))
new_primEqInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_primPlusNat0(Succ(x0), Zero)
new_compare113(x0, x1, x2, x3, True, x4, x5)
new_ltEs18(Left(x0), Left(x1), app(app(ty_@2, x2), x3), x4)
new_ltEs13(@3(x0, x1, x2), @3(x3, x4, x5), x6, x7, x8)
new_esEs16(True, True)
new_esEs4(x0, x1, ty_Bool)
new_primPlusNat0(Zero, Succ(x0))
new_esEs40(x0, x1, ty_Integer)
new_esEs35(x0, x1, app(app(ty_Either, x2), x3))
new_lt20(x0, x1, ty_Ordering)
new_lt21(x0, x1, ty_Char)
new_esEs6(x0, x1, ty_Char)
new_esEs40(x0, x1, app(ty_Maybe, x2))
new_compare7(x0, x1, app(ty_[], x2))
new_esEs40(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs40(x0, x1, app(app(ty_Either, x2), x3))
new_esEs28(x0, x1, ty_Bool)
new_lt5(x0, x1, ty_Float)
new_esEs26(EQ)
new_ltEs4(x0, x1, app(ty_Maybe, x2))
new_esEs14(Nothing, Just(x0), x1)
new_ltEs9(Just(x0), Just(x1), ty_Int)
new_compare6(Nothing, Nothing, x0)
new_ltEs4(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_compare7(x0, x1, ty_Bool)
new_esEs27(x0, x1, ty_Float)
new_ltEs11(x0, x1)
new_esEs39(x0, x1, ty_Double)
new_compare115(x0, x1, False, x2, x3)
new_esEs22(Left(x0), Left(x1), app(ty_[], x2), x3)
new_ltEs18(Right(x0), Right(x1), x2, app(ty_[], x3))
new_ltEs20(x0, x1, app(app(ty_Either, x2), x3))
new_esEs10(x0, x1, app(app(ty_@2, x2), x3))
new_esEs35(x0, x1, ty_Bool)
new_lt23(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs22(x0, x1, ty_Int)
new_esEs14(Nothing, Nothing, x0)
new_esEs26(GT)
new_esEs8(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_ltEs19(x0, x1, ty_Ordering)
new_ltEs18(Right(x0), Right(x1), x2, ty_Double)
new_ltEs4(x0, x1, app(app(ty_Either, x2), x3))
new_lt19(x0, x1, ty_Double)
new_lt19(x0, x1, app(app(ty_@2, x2), x3))
new_lt24(x0, x1, ty_Int)
new_esEs17(@2(x0, x1), @2(x2, x3), x4, x5)
new_lt5(x0, x1, ty_Double)
new_esEs28(x0, x1, ty_Int)
new_esEs29(x0, x1, ty_Int)
new_lt23(x0, x1, ty_Bool)
new_ltEs4(x0, x1, ty_Int)
new_compare0(:(x0, x1), [], x2)
new_compare114(x0, x1, x2, x3, x4, x5, True, x6, x7, x8)
new_esEs11(x0, x1, app(app(ty_Either, x2), x3))
new_esEs31(x0, x1, ty_Char)
new_esEs30(x0, x1, app(app(ty_Either, x2), x3))
new_lt22(x0, x1, app(ty_Maybe, x2))
new_ltEs22(x0, x1, app(ty_Maybe, x2))
new_ltEs24(x0, x1, app(app(ty_Either, x2), x3))
new_ltEs22(x0, x1, ty_Float)
new_compare113(x0, x1, x2, x3, False, x4, x5)
new_ltEs23(x0, x1, app(ty_Ratio, x2))
new_ltEs19(x0, x1, ty_Bool)
new_compare7(x0, x1, ty_@0)
new_esEs28(x0, x1, app(ty_Ratio, x2))
new_esEs41(GT)
new_ltEs8(x0, x1)
new_esEs10(x0, x1, ty_Integer)
new_lt19(x0, x1, ty_Char)
new_esEs10(x0, x1, ty_Char)
new_compare12(Integer(x0), Integer(x1))
new_compare29(x0, x1, False, x2)
new_compare112(x0, x1, True, x2)
new_ltEs19(x0, x1, ty_Double)
new_lt24(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_gt(x0, x1, ty_Bool)
new_esEs29(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs32(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs33(x0, x1, ty_Bool)
new_esEs32(x0, x1, ty_Ordering)
new_esEs39(x0, x1, ty_Int)
new_esEs28(x0, x1, ty_Double)
new_esEs27(x0, x1, ty_@0)
new_esEs7(x0, x1, ty_@0)
new_lt20(x0, x1, app(ty_[], x2))
new_esEs15(:(x0, x1), :(x2, x3), x4)
new_esEs18(Char(x0), Char(x1))
new_esEs6(x0, x1, ty_Int)
new_primPlusNat0(Zero, Zero)
new_esEs9(x0, x1, app(ty_Ratio, x2))
new_ltEs4(x0, x1, ty_Ordering)
new_esEs7(x0, x1, ty_Double)
new_lt20(x0, x1, app(app(ty_@2, x2), x3))
new_esEs8(x0, x1, ty_@0)
new_lt23(x0, x1, app(ty_[], x2))
new_esEs10(x0, x1, app(ty_[], x2))
new_primCompAux0(x0, x1, x2, x3)
new_esEs8(x0, x1, app(app(ty_@2, x2), x3))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_esEs22(Right(x0), Right(x1), x2, app(app(app(ty_@3, x3), x4), x5))
new_esEs14(Just(x0), Just(x1), app(ty_Ratio, x2))
new_lt22(x0, x1, app(app(ty_Either, x2), x3))
new_ltEs23(x0, x1, ty_Ordering)
new_esEs41(EQ)
new_lt19(x0, x1, ty_Ordering)
new_lt21(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_ltEs6(True, False)
new_ltEs6(False, True)
new_fsEs(x0)
new_esEs11(x0, x1, app(ty_[], x2))
new_esEs10(x0, x1, app(ty_Maybe, x2))
new_gt(x0, x1, app(app(ty_@2, x2), x3))
new_esEs38(x0, x1, ty_Int)
new_esEs37(x0, x1, ty_Integer)
new_primEqNat0(Succ(x0), Succ(x1))
new_ltEs18(Left(x0), Left(x1), app(ty_[], x2), x3)
new_esEs29(x0, x1, ty_Ordering)
new_esEs22(Left(x0), Left(x1), ty_Double, x2)
new_ltEs9(Just(x0), Just(x1), ty_@0)
new_primEqInt(Neg(Succ(x0)), Neg(Zero))
new_esEs22(Left(x0), Left(x1), ty_Char, x2)
new_ltEs9(Just(x0), Just(x1), app(ty_[], x2))
new_esEs40(x0, x1, ty_Char)
new_esEs11(x0, x1, ty_Char)
new_compare18(Left(x0), Left(x1), x2, x3)
new_ltEs24(x0, x1, app(ty_[], x2))
new_ltEs18(Left(x0), Left(x1), ty_Double, x2)
new_ltEs18(Right(x0), Right(x1), x2, ty_Ordering)
new_ltEs9(Just(x0), Just(x1), app(app(ty_@2, x2), x3))
new_ltEs17(@2(x0, x1), @2(x2, x3), x4, x5)
new_lt20(x0, x1, ty_Bool)
new_primEqInt(Pos(Zero), Neg(Zero))
new_primEqInt(Neg(Zero), Pos(Zero))
new_ltEs23(x0, x1, app(ty_[], x2))
new_esEs7(x0, x1, ty_Ordering)
new_lt20(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs6(x0, x1, ty_Integer)
new_compare7(x0, x1, app(app(ty_Either, x2), x3))
new_esEs6(x0, x1, ty_Double)
new_lt22(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs10(x0, x1, ty_Double)
new_esEs28(x0, x1, ty_Ordering)
new_esEs4(x0, x1, app(app(ty_Either, x2), x3))
new_esEs34(x0, x1, ty_Float)
new_esEs39(x0, x1, app(app(ty_Either, x2), x3))
new_ltEs18(Left(x0), Left(x1), ty_Float, x2)
new_compare7(x0, x1, ty_Ordering)
new_esEs7(x0, x1, ty_Char)
new_compare6(Just(x0), Just(x1), x2)
new_esEs5(x0, x1, app(app(ty_Either, x2), x3))
new_esEs33(x0, x1, ty_Double)
new_lt19(x0, x1, app(ty_[], x2))
new_ltEs18(Right(x0), Right(x1), x2, ty_Char)
new_esEs7(x0, x1, app(ty_Ratio, x2))
new_esEs31(x0, x1, ty_Ordering)
new_esEs34(x0, x1, ty_Integer)
new_compare14(@0, @0)
new_esEs22(Right(x0), Right(x1), x2, ty_Ordering)
new_lt21(x0, x1, app(ty_[], x2))
new_lt22(x0, x1, ty_Ordering)
new_esEs39(x0, x1, app(ty_Ratio, x2))
new_lt22(x0, x1, app(ty_Ratio, x2))
new_lt5(x0, x1, app(app(ty_Either, x2), x3))
new_lt24(x0, x1, ty_Bool)
new_ltEs21(x0, x1, ty_Ordering)
new_ltEs9(Nothing, Just(x0), x1)
new_lt9(x0, x1)
new_esEs11(x0, x1, app(ty_Ratio, x2))
new_lt5(x0, x1, ty_Int)
new_esEs22(Left(x0), Left(x1), ty_Int, x2)
new_lt6(x0, x1)
new_lt23(x0, x1, ty_Float)
new_esEs33(x0, x1, ty_Ordering)
new_primMulInt(Neg(x0), Pos(x1))
new_primMulInt(Pos(x0), Neg(x1))
new_compare8(LT, GT)
new_compare0(:(x0, x1), :(x2, x3), x4)
new_compare8(GT, LT)
new_esEs4(x0, x1, ty_Char)
new_ltEs18(Right(x0), Left(x1), x2, x3)
new_ltEs18(Left(x0), Right(x1), x2, x3)
new_pePe(False, x0)
new_gt(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_lt22(x0, x1, ty_Float)
new_compare7(x0, x1, ty_Int)
new_esEs27(x0, x1, app(ty_Ratio, x2))
new_esEs10(x0, x1, ty_@0)
new_lt20(x0, x1, ty_Int)
new_compare17(@2(x0, x1), @2(x2, x3), x4, x5)
new_ltEs4(x0, x1, ty_Integer)
new_ltEs19(x0, x1, ty_Int)
new_compare29(x0, x1, True, x2)
new_lt22(x0, x1, ty_Int)
new_esEs22(Left(x0), Left(x1), app(app(app(ty_@3, x2), x3), x4), x5)
new_esEs31(x0, x1, app(ty_[], x2))
new_ltEs21(x0, x1, ty_Double)
new_ltEs9(Just(x0), Nothing, x1)
new_primCmpNat0(Zero, Zero)
new_ltEs23(x0, x1, ty_Int)
new_lt24(x0, x1, ty_@0)
new_esEs11(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs7(x0, x1, app(app(ty_Either, x2), x3))
new_asAs(True, x0)
new_esEs31(x0, x1, ty_Integer)
new_ltEs21(x0, x1, app(app(ty_@2, x2), x3))
new_esEs7(x0, x1, ty_Bool)
new_ltEs10(x0, x1)
new_esEs6(x0, x1, ty_Bool)
new_esEs29(x0, x1, app(app(ty_@2, x2), x3))
new_lt24(x0, x1, ty_Integer)
new_ltEs22(x0, x1, app(app(ty_Either, x2), x3))
new_compare10(:%(x0, x1), :%(x2, x3), ty_Integer)
new_esEs14(Just(x0), Just(x1), ty_Integer)
new_esEs11(x0, x1, ty_Ordering)
new_esEs38(x0, x1, ty_Ordering)
new_lt19(x0, x1, app(ty_Maybe, x2))
new_compare7(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_lt24(x0, x1, ty_Char)
new_esEs9(x0, x1, ty_Ordering)
new_esEs38(x0, x1, app(app(ty_Either, x2), x3))
new_esEs38(x0, x1, ty_Double)
new_compare8(LT, LT)
new_ltEs19(x0, x1, app(app(ty_Either, x2), x3))
new_esEs14(Just(x0), Just(x1), ty_Float)
new_ltEs23(x0, x1, app(ty_Maybe, x2))
new_esEs25(Integer(x0), Integer(x1))
new_esEs41(LT)
new_esEs28(x0, x1, ty_Float)
new_esEs5(x0, x1, ty_Bool)
new_esEs10(x0, x1, app(ty_Ratio, x2))
new_ltEs22(x0, x1, ty_@0)
new_ltEs20(x0, x1, ty_Integer)
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_ltEs20(x0, x1, app(ty_Maybe, x2))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_lt19(x0, x1, ty_Int)
new_esEs32(x0, x1, ty_@0)
new_primEqNat0(Succ(x0), Zero)
new_esEs27(x0, x1, ty_Double)
new_lt22(x0, x1, ty_Integer)
new_ltEs19(x0, x1, app(ty_Maybe, x2))
new_esEs14(Just(x0), Just(x1), app(ty_Maybe, x2))
new_lt21(x0, x1, app(ty_Maybe, x2))
new_esEs34(x0, x1, app(app(ty_Either, x2), x3))
new_gt(x0, x1, ty_Ordering)
new_esEs28(x0, x1, app(app(ty_Either, x2), x3))
new_esEs6(x0, x1, app(app(ty_Either, x2), x3))
new_lt22(x0, x1, ty_Char)
new_ltEs5(EQ, EQ)
new_esEs27(x0, x1, ty_Char)
new_esEs32(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs19(x0, x1, ty_Integer)
new_esEs8(x0, x1, ty_Double)
new_ltEs18(Right(x0), Right(x1), x2, ty_Int)
new_lt24(x0, x1, app(ty_Ratio, x2))
new_esEs35(x0, x1, ty_Double)
new_ltEs18(Right(x0), Right(x1), x2, app(ty_Ratio, x3))
new_esEs33(x0, x1, app(ty_[], x2))
new_esEs32(x0, x1, ty_Float)
new_esEs15(:(x0, x1), [], x2)
new_esEs11(x0, x1, ty_@0)
new_ltEs19(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs23(x0, x1, ty_@0)
new_esEs5(x0, x1, ty_Int)
new_esEs21(EQ, EQ)
new_esEs35(x0, x1, app(ty_Ratio, x2))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_ltEs24(x0, x1, ty_Char)
new_ltEs18(Right(x0), Right(x1), x2, app(app(app(ty_@3, x3), x4), x5))
new_esEs5(x0, x1, ty_Integer)
new_lt23(x0, x1, app(app(ty_Either, x2), x3))
new_ltEs22(x0, x1, ty_Ordering)
new_lt5(x0, x1, ty_Ordering)
new_esEs34(x0, x1, ty_Double)
new_ltEs23(x0, x1, app(app(ty_Either, x2), x3))
new_esEs8(x0, x1, ty_Int)
new_primCmpNat0(Succ(x0), Succ(x1))
new_ltEs21(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs14(Just(x0), Just(x1), app(app(ty_@2, x2), x3))
new_lt21(x0, x1, ty_@0)
new_lt16(x0, x1, x2)
new_esEs40(x0, x1, ty_@0)
new_ltEs9(Just(x0), Just(x1), ty_Float)
new_esEs7(x0, x1, app(ty_[], x2))
new_lt23(x0, x1, ty_Int)
new_ltEs22(x0, x1, app(ty_Ratio, x2))
new_esEs35(x0, x1, app(ty_[], x2))
new_esEs24(:%(x0, x1), :%(x2, x3), x4)
new_esEs35(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs23(x0, x1, ty_Float)
new_ltEs18(Right(x0), Right(x1), x2, app(ty_Maybe, x3))
new_ltEs20(x0, x1, app(ty_Ratio, x2))
new_lt23(x0, x1, ty_@0)
new_compare28(x0, x1, False, x2, x3)
new_esEs27(x0, x1, app(app(ty_@2, x2), x3))
new_lt20(x0, x1, app(app(ty_Either, x2), x3))
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_lt21(x0, x1, ty_Integer)
new_compare28(x0, x1, True, x2, x3)
new_esEs8(x0, x1, app(app(ty_Either, x2), x3))
new_esEs7(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs39(x0, x1, app(ty_[], x2))
new_esEs33(x0, x1, ty_Char)
new_esEs35(x0, x1, ty_Ordering)
new_lt19(x0, x1, ty_Integer)
new_lt5(x0, x1, app(ty_Ratio, x2))
new_lt11(x0, x1)
new_esEs4(x0, x1, app(ty_Ratio, x2))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_lt15(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba)), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_lt15(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba)), h, ba)

The TRS R consists of the following rules:

new_primMulNat0(Zero, Zero) → Zero
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_esEs26(GT) → False
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_esEs26(EQ) → False
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Pos(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_compare16(zwu40, zwu60) → new_primCmpInt(zwu40, zwu60)
new_primMulNat1(Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primMulInt(Neg(zwu4000), Neg(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_sIZE_RATIO → Pos(Succ(Succ(Succ(Succ(Succ(Zero))))))
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_esEs26(LT) → True
new_primPlusNat0(Zero, Zero) → Zero
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_sr(zwu400, zwu601) → new_primMulInt(zwu400, zwu601)
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_lt15(zwu40, zwu60) → new_esEs26(new_compare16(zwu40, zwu60))
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_sizeFM0(EmptyFM, bb, bc) → Pos(Zero)

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr(x0, x1)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_lt15(x0, x1)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_compare16(x0, x1)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)
new_sIZE_RATIO

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_lt15(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba)), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_lt15(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba)), h, ba)

The TRS R consists of the following rules:

new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sIZE_RATIO → Pos(Succ(Succ(Succ(Succ(Succ(Zero))))))
new_sr(zwu400, zwu601) → new_primMulInt(zwu400, zwu601)
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_lt15(zwu40, zwu60) → new_esEs26(new_compare16(zwu40, zwu60))
new_compare16(zwu40, zwu60) → new_primCmpInt(zwu40, zwu60)
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Pos(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Neg(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr(x0, x1)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_lt15(x0, x1)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_compare16(x0, x1)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)
new_sIZE_RATIO

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_lt15(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba)), h, ba) at position [12] we obtained the following new rules:

new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_compare16(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_compare16(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_lt15(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba)), h, ba)

The TRS R consists of the following rules:

new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sIZE_RATIO → Pos(Succ(Succ(Succ(Succ(Succ(Zero))))))
new_sr(zwu400, zwu601) → new_primMulInt(zwu400, zwu601)
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_lt15(zwu40, zwu60) → new_esEs26(new_compare16(zwu40, zwu60))
new_compare16(zwu40, zwu60) → new_primCmpInt(zwu40, zwu60)
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Pos(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Neg(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr(x0, x1)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_lt15(x0, x1)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_compare16(x0, x1)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)
new_sIZE_RATIO

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba))), h, ba) at position [12,0,1] we obtained the following new rules:

new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba))), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_compare16(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_lt15(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba)), h, ba)

The TRS R consists of the following rules:

new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sIZE_RATIO → Pos(Succ(Succ(Succ(Succ(Succ(Zero))))))
new_sr(zwu400, zwu601) → new_primMulInt(zwu400, zwu601)
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_lt15(zwu40, zwu60) → new_esEs26(new_compare16(zwu40, zwu60))
new_compare16(zwu40, zwu60) → new_primCmpInt(zwu40, zwu60)
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Pos(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Neg(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr(x0, x1)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_lt15(x0, x1)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_compare16(x0, x1)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)
new_sIZE_RATIO

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba))), h, ba) at position [12,0,1] we obtained the following new rules:

new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_compare16(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_lt15(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba)), h, ba)

The TRS R consists of the following rules:

new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sIZE_RATIO → Pos(Succ(Succ(Succ(Succ(Succ(Zero))))))
new_sr(zwu400, zwu601) → new_primMulInt(zwu400, zwu601)
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_lt15(zwu40, zwu60) → new_esEs26(new_compare16(zwu40, zwu60))
new_compare16(zwu40, zwu60) → new_primCmpInt(zwu40, zwu60)
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Pos(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Neg(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr(x0, x1)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_lt15(x0, x1)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_compare16(x0, x1)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)
new_sIZE_RATIO

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_lt15(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba)), h, ba) at position [12] we obtained the following new rules:

new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_compare16(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_compare16(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_compare16(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)

The TRS R consists of the following rules:

new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sIZE_RATIO → Pos(Succ(Succ(Succ(Succ(Succ(Zero))))))
new_sr(zwu400, zwu601) → new_primMulInt(zwu400, zwu601)
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_lt15(zwu40, zwu60) → new_esEs26(new_compare16(zwu40, zwu60))
new_compare16(zwu40, zwu60) → new_primCmpInt(zwu40, zwu60)
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Pos(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Neg(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr(x0, x1)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_lt15(x0, x1)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_compare16(x0, x1)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)
new_sIZE_RATIO

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_compare16(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_compare16(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)

The TRS R consists of the following rules:

new_sIZE_RATIO → Pos(Succ(Succ(Succ(Succ(Succ(Zero))))))
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_sr(zwu400, zwu601) → new_primMulInt(zwu400, zwu601)
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_compare16(zwu40, zwu60) → new_primCmpInt(zwu40, zwu60)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Pos(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Neg(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr(x0, x1)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_lt15(x0, x1)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_compare16(x0, x1)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)
new_sIZE_RATIO

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_lt15(x0, x1)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_compare16(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_compare16(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)

The TRS R consists of the following rules:

new_sIZE_RATIO → Pos(Succ(Succ(Succ(Succ(Succ(Zero))))))
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_sr(zwu400, zwu601) → new_primMulInt(zwu400, zwu601)
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_compare16(zwu40, zwu60) → new_primCmpInt(zwu40, zwu60)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Pos(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Neg(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr(x0, x1)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_compare16(x0, x1)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)
new_sIZE_RATIO

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba))), h, ba) at position [12,0,1] we obtained the following new rules:

new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_compare16(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_compare16(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_sIZE_RATIO → Pos(Succ(Succ(Succ(Succ(Succ(Zero))))))
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_sr(zwu400, zwu601) → new_primMulInt(zwu400, zwu601)
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_compare16(zwu40, zwu60) → new_primCmpInt(zwu40, zwu60)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Pos(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Neg(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr(x0, x1)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_compare16(x0, x1)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)
new_sIZE_RATIO

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_compare16(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba) at position [12,0] we obtained the following new rules:

new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_compare16(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_sIZE_RATIO → Pos(Succ(Succ(Succ(Succ(Succ(Zero))))))
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_sr(zwu400, zwu601) → new_primMulInt(zwu400, zwu601)
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_compare16(zwu40, zwu60) → new_primCmpInt(zwu40, zwu60)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Pos(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Neg(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr(x0, x1)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_compare16(x0, x1)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)
new_sIZE_RATIO

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba))), h, ba) at position [12,0,1] we obtained the following new rules:

new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_compare16(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_sIZE_RATIO → Pos(Succ(Succ(Succ(Succ(Succ(Zero))))))
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_sr(zwu400, zwu601) → new_primMulInt(zwu400, zwu601)
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_compare16(zwu40, zwu60) → new_primCmpInt(zwu40, zwu60)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Pos(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Neg(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr(x0, x1)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_compare16(x0, x1)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)
new_sIZE_RATIO

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_compare16(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba) at position [12,0] we obtained the following new rules:

new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_sIZE_RATIO → Pos(Succ(Succ(Succ(Succ(Succ(Zero))))))
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_sr(zwu400, zwu601) → new_primMulInt(zwu400, zwu601)
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_compare16(zwu40, zwu60) → new_primCmpInt(zwu40, zwu60)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Pos(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Neg(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr(x0, x1)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_compare16(x0, x1)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)
new_sIZE_RATIO

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_sIZE_RATIO → Pos(Succ(Succ(Succ(Succ(Succ(Zero))))))
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_sr(zwu400, zwu601) → new_primMulInt(zwu400, zwu601)
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Pos(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Neg(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr(x0, x1)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_compare16(x0, x1)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)
new_sIZE_RATIO

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_compare16(x0, x1)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_sIZE_RATIO → Pos(Succ(Succ(Succ(Succ(Succ(Zero))))))
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_sr(zwu400, zwu601) → new_primMulInt(zwu400, zwu601)
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Pos(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Neg(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr(x0, x1)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)
new_sIZE_RATIO

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba) at position [12,0,0] we obtained the following new rules:

new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_sIZE_RATIO → Pos(Succ(Succ(Succ(Succ(Succ(Zero))))))
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_sr(zwu400, zwu601) → new_primMulInt(zwu400, zwu601)
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Pos(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Neg(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr(x0, x1)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)
new_sIZE_RATIO

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_sr(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba) at position [12,0,0] we obtained the following new rules:

new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_sIZE_RATIO → Pos(Succ(Succ(Succ(Succ(Succ(Zero))))))
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_sr(zwu400, zwu601) → new_primMulInt(zwu400, zwu601)
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Pos(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Neg(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr(x0, x1)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)
new_sIZE_RATIO

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                                                                                    ↳ QReductionProof
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_sIZE_RATIO → Pos(Succ(Succ(Succ(Succ(Succ(Zero))))))
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Pos(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Neg(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_sr(x0, x1)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)
new_sIZE_RATIO

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_sr(x0, x1)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                                                                                    ↳ QReductionProof
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_sIZE_RATIO → Pos(Succ(Succ(Succ(Succ(Succ(Zero))))))
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Pos(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Neg(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)
new_sIZE_RATIO

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(new_sIZE_RATIO, new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba) at position [12,0,0,0] we obtained the following new rules:

new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                                                                                    ↳ QReductionProof
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_sIZE_RATIO → Pos(Succ(Succ(Succ(Succ(Succ(Zero))))))
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Pos(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Neg(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)
new_sIZE_RATIO

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(new_sIZE_RATIO, new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba) at position [12,0,0,0] we obtained the following new rules:

new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                                                                                    ↳ QReductionProof
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ UsableRulesProof
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_sIZE_RATIO → Pos(Succ(Succ(Succ(Succ(Succ(Zero))))))
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Pos(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Neg(zwu4000), Neg(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)
new_sIZE_RATIO

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                                                                                    ↳ QReductionProof
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ UsableRulesProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ QReductionProof
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)
new_sIZE_RATIO

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_sIZE_RATIO



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                                                                                    ↳ QReductionProof
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ UsableRulesProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ QReductionProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Rewriting
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba) at position [12,0,0,1] we obtained the following new rules:

new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                                                                                    ↳ QReductionProof
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ UsableRulesProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ QReductionProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Rewriting
                                                                                                                          ↳ QDP
                                                                                                                            ↳ UsableRulesProof
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_mkVBalBranch3Size_r(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                                                                                    ↳ QReductionProof
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ UsableRulesProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ QReductionProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Rewriting
                                                                                                                          ↳ QDP
                                                                                                                            ↳ UsableRulesProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ QReductionProof
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_mkVBalBranch3Size_r(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                                                                                    ↳ QReductionProof
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ UsableRulesProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ QReductionProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Rewriting
                                                                                                                          ↳ QDP
                                                                                                                            ↳ UsableRulesProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ QReductionProof
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Rewriting
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba) at position [12,0,0,1] we obtained the following new rules:

new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                                                                                    ↳ QReductionProof
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ UsableRulesProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ QReductionProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Rewriting
                                                                                                                          ↳ QDP
                                                                                                                            ↳ UsableRulesProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ QReductionProof
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Rewriting
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Rewriting
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba) at position [12,0,0,1] we obtained the following new rules:

new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                                                                                    ↳ QReductionProof
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ UsableRulesProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ QReductionProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Rewriting
                                                                                                                          ↳ QDP
                                                                                                                            ↳ UsableRulesProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ QReductionProof
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Rewriting
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Rewriting
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ UsableRulesProof
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_mkVBalBranch3Size_r0(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, h, ba) → new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82
new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                                                                                    ↳ QReductionProof
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ UsableRulesProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ QReductionProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Rewriting
                                                                                                                          ↳ QDP
                                                                                                                            ↳ UsableRulesProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ QReductionProof
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Rewriting
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Rewriting
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ UsableRulesProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QReductionProof
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_mkVBalBranch3Size_r0(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                                                                                    ↳ QReductionProof
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ UsableRulesProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ QReductionProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Rewriting
                                                                                                                          ↳ QDP
                                                                                                                            ↳ UsableRulesProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ QReductionProof
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Rewriting
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Rewriting
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ UsableRulesProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QReductionProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), new_sizeFM0(Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), h, ba))), h, ba) at position [12,0,1] we obtained the following new rules:

new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), Pos(zwu720))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                                                                                    ↳ QReductionProof
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ UsableRulesProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ QReductionProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Rewriting
                                                                                                                          ↳ QDP
                                                                                                                            ↳ UsableRulesProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ QReductionProof
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Rewriting
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Rewriting
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ UsableRulesProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QReductionProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Rewriting
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), Pos(zwu720))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), new_sizeFM(zwu60, zwu61, zwu62, zwu63, zwu64, h, ba)), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba) at position [12,0,0,1] we obtained the following new rules:

new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                                                                                    ↳ QReductionProof
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ UsableRulesProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ QReductionProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Rewriting
                                                                                                                          ↳ QDP
                                                                                                                            ↳ UsableRulesProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ QReductionProof
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Rewriting
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Rewriting
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ UsableRulesProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QReductionProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Rewriting
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ UsableRulesProof
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), Pos(zwu720))), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_sizeFM(zwu80, zwu81, zwu82, zwu83, zwu84, h, ba) → zwu82

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                                                                                    ↳ QReductionProof
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ UsableRulesProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ QReductionProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Rewriting
                                                                                                                          ↳ QDP
                                                                                                                            ↳ UsableRulesProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ QReductionProof
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Rewriting
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Rewriting
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ UsableRulesProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QReductionProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Rewriting
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ UsableRulesProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ QReductionProof
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), Pos(zwu720))), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)
new_sizeFM(x0, x1, x2, x3, x4, x5, x6)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_sizeFM(x0, x1, x2, x3, x4, x5, x6)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                                                                                    ↳ QReductionProof
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ UsableRulesProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ QReductionProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Rewriting
                                                                                                                          ↳ QDP
                                                                                                                            ↳ UsableRulesProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ QReductionProof
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Rewriting
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Rewriting
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ UsableRulesProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QReductionProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Rewriting
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ UsableRulesProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ QReductionProof
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ Rewriting
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), Pos(zwu720))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), new_sizeFM0(Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), h, ba))), h, ba) at position [12,0,1] we obtained the following new rules:

new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), Neg(zwu720))), h, ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                                                                                    ↳ QReductionProof
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ UsableRulesProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ QReductionProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Rewriting
                                                                                                                          ↳ QDP
                                                                                                                            ↳ UsableRulesProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ QReductionProof
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Rewriting
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Rewriting
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ UsableRulesProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QReductionProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Rewriting
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ UsableRulesProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ QReductionProof
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ UsableRulesProof
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), Pos(zwu720))), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), Neg(zwu720))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))
new_sizeFM0(Branch(zwu230, zwu231, zwu232, zwu233, zwu234), bb, bc) → zwu232
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                                                                                    ↳ QReductionProof
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ UsableRulesProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ QReductionProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Rewriting
                                                                                                                          ↳ QDP
                                                                                                                            ↳ UsableRulesProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ QReductionProof
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Rewriting
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Rewriting
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ UsableRulesProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QReductionProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Rewriting
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ UsableRulesProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ QReductionProof
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ QReductionProof
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), Pos(zwu720))), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), Neg(zwu720))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_primMulInt(Neg(x0), Neg(x1))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_sizeFM0(EmptyFM, x0, x1)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_sizeFM0(Branch(x0, x1, x2, x3, x4), x5, x6)
new_sizeFM0(EmptyFM, x0, x1)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                                                                                    ↳ QReductionProof
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ UsableRulesProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ QReductionProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Rewriting
                                                                                                                          ↳ QDP
                                                                                                                            ↳ UsableRulesProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ QReductionProof
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Rewriting
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Rewriting
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ UsableRulesProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QReductionProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Rewriting
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ UsableRulesProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ QReductionProof
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ QDPOrderProof
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), Pos(zwu720))), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), Neg(zwu720))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_primMulInt(Neg(x0), Neg(x1))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), Pos(zwu720))), h, ba)
new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Neg(new_primMulNat1(zwu720)), zwu62)), h, ba)
The remaining pairs can at least be oriented weakly.

new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), Neg(zwu720))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)
Used ordering: Polynomial interpretation [25]:

POL(Branch(x1, x2, x3, x4, x5)) = 1 + x1 + x3 + x4 + x5   
POL(EQ) = 0   
POL(False) = 1   
POL(GT) = 0   
POL(LT) = 0   
POL(Neg(x1)) = 1   
POL(Pos(x1)) = 0   
POL(Succ(x1)) = 0   
POL(True) = 1   
POL(Zero) = 0   
POL(new_esEs26(x1)) = 1   
POL(new_mkVBalBranch(x1, x2, x3, x4, x5, x6)) = x3 + x4   
POL(new_mkVBalBranch3MkVBalBranch1(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)) = 1 + x1 + x10 + x3 + x4 + x5 + x6   
POL(new_mkVBalBranch3MkVBalBranch10(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)) = 1 + x1 + x10 + x13 + x3 + x4 + x5 + x9   
POL(new_mkVBalBranch3MkVBalBranch2(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)) = 1 + x1 + x10 + x13 + x3 + x4 + x5 + x6 + x9   
POL(new_mkVBalBranch3MkVBalBranch20(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)) = 1 + x1 + x10 + x13 + x3 + x4 + x5 + x6 + x9   
POL(new_primCmpInt(x1, x2)) = 0   
POL(new_primCmpNat0(x1, x2)) = 0   
POL(new_primMulInt(x1, x2)) = 0   
POL(new_primMulNat0(x1, x2)) = 1   
POL(new_primMulNat1(x1)) = 0   
POL(new_primPlusNat0(x1, x2)) = 0   

The following usable rules [17] were oriented:

new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ UsableRulesProof
                                                          ↳ QDP
                                                            ↳ QReductionProof
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ UsableRulesProof
                                                                                  ↳ QDP
                                                                                    ↳ QReductionProof
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ UsableRulesProof
                                                                                                  ↳ QDP
                                                                                                    ↳ QReductionProof
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ UsableRulesProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ QReductionProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Rewriting
                                                                                                                          ↳ QDP
                                                                                                                            ↳ UsableRulesProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ QReductionProof
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Rewriting
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Rewriting
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ UsableRulesProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ QReductionProof
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Rewriting
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Rewriting
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ UsableRulesProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ QReductionProof
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ Rewriting
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ QReductionProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ QDPOrderProof
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, False, h, ba) → new_mkVBalBranch3MkVBalBranch10(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(new_primMulInt(Pos(Succ(Succ(Succ(Succ(Succ(Zero)))))), zwu62), Neg(zwu720))), h, ba)
new_mkVBalBranch3MkVBalBranch20(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Neg(zwu720), zwu73, zwu74), zwu63, h, ba)
new_mkVBalBranch3MkVBalBranch1(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, True, h, ba) → new_mkVBalBranch(zwu40, zwu41, zwu74, Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba)
new_mkVBalBranch(zwu40, zwu41, Branch(zwu70, zwu71, Pos(zwu720), zwu73, zwu74), Branch(zwu60, zwu61, zwu62, zwu63, zwu64), h, ba) → new_mkVBalBranch3MkVBalBranch2(zwu60, zwu61, zwu62, zwu63, zwu64, zwu70, zwu71, zwu720, zwu73, zwu74, zwu40, zwu41, new_esEs26(new_primCmpInt(Pos(new_primMulNat1(zwu720)), zwu62)), h, ba)

The TRS R consists of the following rules:

new_primMulNat1(Succ(zwu5400)) → new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(new_primPlusNat0(Zero, Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400)), Succ(zwu5400))
new_primMulNat1(Zero) → Zero
new_primCmpInt(Pos(Succ(zwu4000)), Neg(zwu600)) → GT
new_primCmpInt(Pos(Zero), Neg(Succ(zwu6000))) → GT
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Pos(Succ(zwu6000))) → new_primCmpNat0(Zero, Succ(zwu6000))
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Zero)) → GT
new_primCmpInt(Pos(Succ(zwu4000)), Pos(Succ(zwu6000))) → new_primCmpNat0(zwu4000, zwu6000)
new_esEs26(GT) → False
new_esEs26(EQ) → False
new_esEs26(LT) → True
new_primCmpNat0(Zero, Succ(zwu6000)) → LT
new_primCmpNat0(Succ(zwu4000), Succ(zwu6000)) → new_primCmpNat0(zwu4000, zwu6000)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(zwu4000), Zero) → GT
new_primPlusNat0(Zero, Succ(zwu12200)) → Succ(zwu12200)
new_primPlusNat0(Succ(zwu44200), Succ(zwu12200)) → Succ(Succ(new_primPlusNat0(zwu44200, zwu12200)))
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(zwu44200), Zero) → Succ(zwu44200)
new_primCmpInt(Neg(Zero), Pos(Succ(zwu6000))) → LT
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Neg(Succ(zwu4000)), Pos(zwu600)) → LT
new_primCmpInt(Neg(Zero), Neg(Succ(zwu6000))) → new_primCmpNat0(Succ(zwu6000), Zero)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Succ(zwu6000))) → new_primCmpNat0(zwu6000, zwu4000)
new_primCmpInt(Neg(Succ(zwu4000)), Neg(Zero)) → LT
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primMulInt(Pos(zwu4000), Pos(zwu6010)) → Pos(new_primMulNat0(zwu4000, zwu6010))
new_primMulInt(Pos(zwu4000), Neg(zwu6010)) → Neg(new_primMulNat0(zwu4000, zwu6010))
new_primMulNat0(Zero, Zero) → Zero
new_primMulNat0(Zero, Succ(zwu60100)) → Zero
new_primMulNat0(Succ(zwu40000), Zero) → Zero
new_primMulNat0(Succ(zwu40000), Succ(zwu60100)) → new_primPlusNat0(new_primMulNat0(zwu40000, Succ(zwu60100)), Succ(zwu60100))

The set Q consists of the following terms:

new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_esEs26(LT)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_primCmpNat0(Zero, Zero)
new_primCmpInt(Neg(Succ(x0)), Neg(Zero))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_primMulNat0(Zero, Succ(x0))
new_primCmpNat0(Succ(x0), Zero)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_primMulNat0(Zero, Zero)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_primPlusNat0(Zero, Succ(x0))
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_primCmpInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_primMulInt(Neg(x0), Neg(x1))
new_primMulNat1(Succ(x0))
new_primMulNat1(Zero)
new_esEs26(GT)
new_primCmpNat0(Zero, Succ(x0))
new_esEs26(EQ)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_primCmpNat0(Succ(x0), Succ(x1))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primMulInt(Pos(x0), Pos(x1))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primPlusNat0(Zero, Zero)
new_primCmpInt(Pos(Succ(x0)), Pos(Zero))
new_primMulNat0(Succ(x0), Zero)
new_primMulNat0(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), Zero)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 0 SCCs with 4 less nodes.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ LetRed
                        ↳ HASKELL
                          ↳ NumRed
                            ↳ HASKELL
                              ↳ Narrow
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof

Q DP problem:
The TRS P consists of the following rules:

new_filterFM(zwu3, Branch(zwu40, zwu41, zwu42, zwu43, zwu44), h, ba) → new_filterFM1(zwu3, zwu40, zwu41, zwu42, zwu43, zwu44, h, ba)
new_filterFM1(zwu3, zwu40, zwu41, zwu42, zwu43, zwu44, h, ba) → new_filterFM(zwu3, zwu43, h, ba)
new_filterFM1(zwu3, zwu40, zwu41, zwu42, zwu43, zwu44, h, ba) → new_filterFM(zwu3, zwu44, h, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: